Example: Custom qsort for Custom Structs in C++

// Custom qsort for Custom Structs
#include <iostream>
#include <string>
#include <vector> // Using vector just for easier printing, but data is C-style array
#include <cstring> // For memcpy

// Function pointer type for comparison (re-using from Approach 1)
typedef int (*CompareFunc)(const void*, const void*);

// Helper function to swap two elements (re-using from Approach 1)
void swap(void* a, void* b, size_t size) {
    char temp[size];
    memcpy(temp, a, size);
    memcpy(a, b, size);
    memcpy(b, temp, size);
}

// Partition function for Quick Sort (re-using from Approach 1)
int partition(void* base, size_t num, size_t size, CompareFunc compar) {
    char* arr = static_cast<char*>(base);
    void* pivot = arr + (num - 1) * size; 

    int i = -1;

    for (int j = 0; j < num - 1; ++j) {
        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 (re-using from Approach 1)
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);

    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 (re-using from Approach 1)
void my_qsort(void* base, size_t num, size_t size, CompareFunc compar) {
    my_qsort_recursive(base, num, size, compar);
}

// Custom struct
struct Person {
    std::string name;
    int age;
};

// Comparison function for Person structs (sort by age, ascending)
int comparePeopleByAge(const void* a, const void* b) {
    const Person* personA = static_cast<const Person*>(a);
    const Person* personB = static_cast<const Person*>(b);
    if (personA->age < personB->age) return -1;
    if (personA->age > personB->age) return 1;
    return 0;
}

// Comparison function for Person structs (sort by name, ascending)
int comparePeopleByName(const void* a, const void* b) {
    const Person* personA = static_cast<const Person*>(a);
    const Person* personB = static_cast<const Person*>(b);
    return personA->name.compare(personB->name);
}


int main() {
    // Step 1: Initialize an array of Person structs
    Person people[] = {
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35},
        {"David", 25},
        {"Eve", 28}
    };
    size_t n = sizeof(people) / sizeof(people[0]);

    cout << "Original people list:" << endl;
    for (size_t i = 0; i < n; ++i) {
        cout << "Name: " << people[i].name << ", Age: " << people[i].age << endl;
    }
    cout << endl;

    // Step 2: Sort the array by age using my_qsort with comparePeopleByAge
    my_qsort(people, n, sizeof(Person), comparePeopleByAge);

    cout << "Sorted by age (ascending):" << endl;
    for (size_t i = 0; i < n; ++i) {
        cout << "Name: " << people[i].name << ", Age: " << people[i].age << endl;
    }
    cout << endl;

    // Step 3: Sort the array by name using my_qsort with comparePeopleByName
    my_qsort(people, n, sizeof(Person), comparePeopleByName);

    cout << "Sorted by name (ascending):" << endl;
    for (size_t i = 0; i < n; ++i) {
        cout << "Name: " << people[i].name << ", Age: " << people[i].age << endl;
    }
    cout << endl;

    return 0;
}