Указатели на функцию

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
/*Создайте функцию сортировки массива.  В функцию сортировки вместе с объектом структуры массива, необходимо передавать функцию с алгоритмом сортировки. Алгоритмы сортировки: • выбором • вставками • пузырьком*/
struct Human
{
    char name[50];
    int age;
    float salary;
};
void PrintHuman(Human* users, int size)
{
    for (int i = 0; i < size; i++)
        std::cout << users[i].name << " " << users[i].age << " " <<users[i].salary << "\n";
    std::cout << "\n";
}
 
 
void SelectionSort(Human* users, int size)
{
    int j = 0;
    int tmp = 0;
    for (int i = 0; i < size; i++) {
        j = i;
        for (int k = i; k < size; k++) {
            if (users[j].age > users[k].age) {
                j = k;
            }
        }
        Human tmp = users[i];
        users[i] = users[j];
        users[j] = tmp;
    }
}
 
 
void BubbleSort(Human* users, int size)
{
    int tmp = 0;
    for (int i = 0; i < size; i++) {
        for (int j = (size - 1); j >= (i + 1); j--) {
            if (users[j].age < users[j - 1].age) {
                Human tmp = users[j];
                users[j] = users[j - 1];
                users[j - 1] = tmp;
            }
        }
    }
}
 
 
//void QuickSort(int* data, int const len)
//{
//    int const lenD = len;
//    int pivot = 0;
//    int ind = lenD / 2;
//    int i, j = 0, k = 0;
//    if (lenD > 1) {
//        int* L = new int[lenD];
//        int* R = new int[lenD];
//        pivot = data[ind];
//        for (i = 0; i < lenD; i++) {
//            if (i != ind) {
//                if (data[i] < pivot) {
//                    L[j] = data[i];
//                    j++;
//                }
//                else {
//                    R[k] = data[i];
//                    k++;
//                }
//            }
//        }
//        quickSort(L, j);
//        quickSort(R, k);
//        for (int cnt = 0; cnt < lenD; cnt++) {
//            if (cnt < j) {
//                data[cnt] = L[cnt];;
//            }
//            else if (cnt == j) {
//                data[cnt] = pivot;
//            }
//            else {
//                data[cnt] = R[cnt - (j + 1)];
//            }
//        }
//    }
//}
 
void InsertionSort(Human* users, int size)
{
    int key = 0;
    int i = 0;
    for (int j = 1; j < size; j++) {
        key = users[j].age;
        i = j - 1;
        while (i >= 0 && users[i].age > key) {
            users[i + 1] = users[i];
            i = i - 1;
            users[i + 1].age = key;
        }
    }
}
 
 
 
int main()
{
    Human* users = new Human[5];
    strcpy(users[0].name, "Sam");
    users[0].age = 16;
    users[0].salary = 9123;
 
    strcpy(users[1].name, "Denis");
    users[1].age = 73;
    users[1].salary = 72123;
 
 
    strcpy(users[2].name, "Pol");
    users[2].age = 25;
    users[2].salary = 129123;
 
 
    strcpy(users[3].name, "Pam");
    users[3].age = 29;
    users[3].salary = 9123;
 
 
    strcpy(users[4].name, "Sandy");
    users[4].age = 27;
    users[4].salary = 89122;
 
 
    
 
    PrintHuman(users, 5);
    UserSort(users, 5);
    PrintHuman(users, 5);
 
}

void foo(void sort(Human*, int), Human* arr, int size)
{
sort(arr, size);
}

#include <iostream>
#include <vector>
#include <algorithm>
 
template<typename Iterator, typename Comparator>
void insertionSort(Iterator begin, Iterator end, Comparator compare) {
    for (auto it = begin; it != end; it++) {
        auto const insertion_point = std::upper_bound(begin, it, *it, compare);
        std::rotate(insertion_point, it, it+1);
    }
}
 
template<typename Iterator, typename Comparator>
void selectionSort(Iterator begin, Iterator end, Comparator compare) {
    while (begin != end && begin + 1 != end) {
        auto min = std::min_element(begin + 1, end, compare);
        std::iter_swap(begin, min);
        ++begin;
    }
}
 
template<typename Iterator, typename Comparator>
void bubbleSort(Iterator begin, Iterator end, Comparator compare) {
    if (begin == end) {
        return;
    }
    for (auto i = begin; i != end - 1; ++i) {
        for (auto j = i + 1; j != end; ++j) {
            if (compare(*j, *i)) {
                std::iter_swap(i, j);
            }
        }
    }
}
 
template<typename Iterator, typename Comparator, typename SortImplementation>
void sort(Iterator begin, Iterator end, Comparator compare, SortImplementation anImplementation) {
    anImplementation(begin, end, compare);
}
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
    for (auto &i : v) {
        out << i << " ";
    }
    return out;
}
 
int main() {
    std::vector<int> source;
    for (int i; std::cin >> i;) {
        source.push_back(i);
    }
 
    std::vector<int> data = source;
    sort(data.begin(), data.end(), std::greater<int>(), bubbleSort<std::vector<int>::iterator, std::greater<int>>);
    std::cout << data << std::endl;
 
    data = source;
    sort(data.begin(), data.end(), std::greater<int>(), selectionSort<std::vector<int>::iterator, std::greater<int>>);
    std::cout << data << std::endl;
 
    data = source;
    sort(data.begin(), data.end(), std::greater<int>(), insertionSort<std::vector<int>::iterator, std::greater<int>>);
    std::cout << data << std::endl;
    return 0;
}