Example: Custom qsort for Integers in C++

// Custom qsort for Integers
#include <iostream>
#include <cstring> // For memcpy in a real qsort, but not strictly needed for this basic example

// Function pointer type for comparison
typedef int (*CompareFunc)(const void*, const void*);

// Helper function to swap two elements
void swap(void* a, void* b, size_t size) {
    // Create a temporary buffer on the stack
    // This is safe for small 'size'. For very large sizes,
    // a dynamically allocated buffer or a different swap strategy might be better.
    char temp[size];
    memcpy(temp, a, size);
    memcpy(a, b, size);
    memcpy(b, temp, size);
}

// Partition function for Quick Sort
int partition(void* base, size_t num, size_t size, CompareFunc compar) {
    // Treat base as a char array to perform byte-level pointer arithmetic
    char* arr = static_cast<char*>(base);
    void* pivot = arr + (num - 1) * size; // Last element as pivot

    int i = -1; // Index of smaller element

    for (int j = 0; j < num - 1; ++j) {
        // Compare current element (arr + j*size) with pivot
        if (compar(arr + j * size, pivot) <= 0) {
            i++;
            swap(arr + i * size, arr + j * size, size);
        }
    }
    swap(arr + (i + 1) * size, pivot, size);
    return (i + 1);
}

// Recursive Quick Sort implementation
void my_qsort_recursive(void* base, size_t num, size_t size, CompareFunc compar) {
    if (num < 2) {
        return;
    }

    int pi = partition(base, num, size, compar);

    // Recursively sort elements before partition and after partition
    my_qsort_recursive(base, pi, size, compar);
    my_qsort_recursive(static_cast<char*>(base) + (pi + 1) * size, num - pi - 1, size, compar);
}

// Main qsort function wrapper
void my_qsort(void* base, size_t num, size_t size, CompareFunc compar) {
    my_qsort_recursive(base, num, size, compar);
}

// Comparison function for integers (ascending order)
int compareInts(const void* a, const void* b) {
    int valA = *static_cast<const int*>(a);
    int valB = *static_cast<const int*>(b);
    if (valA < valB) return -1;
    if (valA > valB) return 1;
    return 0;
}

int main() {
    // Step 1: Initialize an array of integers
    int arr[] = {5, 2, 8, 1, 9, 3};
    size_t n = sizeof(arr) / sizeof(arr[0]);

    cout << "Original array: ";
    for (size_t i = 0; i < n; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // Step 2: Sort the array using my_qsort with compareInts
    my_qsort(arr, n, sizeof(int), compareInts);

    cout << "Sorted array (ascending): ";
    for (size_t i = 0; i < n; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}