Шаблонные функции и параметры-функций

template<typename T>
float testSortDuration(const T *Array, const &N size, void(*sortFunction)(T *, const int &));
 
template<typename T>
void bucketSort(T* b, const int &n);

testSortDuration(arrayCopy, n, bucketsort);

testSortDuration<int>(arrayCopy, n, bucketsort);

template<typename T, typename F = void(T*, const int)>
void benchmark(T* arr, const int size, F* fn)
{
    fn(arr, size);
}

template<typename T>
void bucketSort(T* b, const int &n); // <----- Это шаблон функции
 
template<typename T>
// а здесь ждем указатель на конкретную функцию
float testSortDuration(const T *Array, const &N size, void(*sortFunction)(T *, const int &)); 
 
testSortDuration(arrayCopy, n, bucketsort); // < --- передали имя шаблона, естественно он на это напишет: "идентификатор "bucketsort" не определен"

testSortDuration(arrayCopy, n, bucketsort<int>); // <---- передаем адрес функции bucketsort<int>

#include <iostream>
 
template<typename T>
void sort_fn(T*, const int)
{
    std::cout << __PRETTY_FUNCTION__ << '\n';
}
 
template<typename T, typename F = void(T*, const int)>
void benchmark(T* arr, const int size, F* fn)
{
    fn(arr, size);
}
 
int main()
{
    int arr[10] = {0};
    double brr[20] = {0};
    
    benchmark(arr, 10, sort_fn);
    benchmark(brr, 20, sort_fn);
}

template <typename T>
using func = void(T *, const int);
 
template<typename T>
void benchmark(T* arr, const int size, func<T> fn)
{
    fn(arr, size);
}

template<typename T, typename F = void(T*, const int &)>
float testSortDuration(const T *Array, const &N size, F *Func)
{
    float begin(clock());
    sortFunction(Array, N, );
    return clock() - begin;
}

#include <iostream>
#include <ctime>
#include <vector>
#include <algorithm>
#include <time.h>
using namespace std;
 
template<typename T>
void CopyArray(const int &, const T *, T *);
 
template<typename T>
void bucketSort(T* b, const int &n);
 
template<typename T>
void insertsort(T* a, const int &n);
 
template<typename T>
void quickSort(T *numbers, int left, int right);
 
bool IsMPow(int n);
 
template < typename T, typename F = void(T *, const int &)>
float testSortDuration(T *Array, const &N size, F *Func);
 
void main() {
    srand(time(NULL));
 
    int n;
    cout << "n= ";
    cin >> n;
 
    int *array = new int [n];
    for (int i(0); i < n; ++i)
        array[i] = rand()%n;
 
    int *arrayCopy = new int[n];
 
    float d1(0), d2(0), d3(0);
 
    for (int i(0); i < 10; ++i)
    {
        CopyArray(n, array, arrayCopy);
        d1 += testSortDuration(arrayCopy, n, bucketSort<int>);
    }
 
    system("pause");
}
 
template<typename T>
void insertsort(T *a, const int &n)
{
    T tmp;
    for (int i = 1, j; i < n; ++i)
    {
        tmp = a[i];
        for (j = i - 1; j >= 0 && a[j] > tmp; --j) // поиск места элемента в готовой последовательности 
            a[j + 1] = a[j];    // сдвигаем элемент направо, пока не дошли
        a[j + 1] = tmp; // место найдено, вставить элемент    
    }
}
 
template<typename T>
void bucketSort(T* b, const int &n) {
 
    T *buckets = new T[n];
    int i, j, k;
 
    for (i = 0; i < n; ++i)
        buckets[i] = 0;
 
    for (i = 0; i < n; ++i)
        ++buckets[b[i]];
 
    for (i = 0, j = 0; j < n; ++j)
        for (k = buckets[j]; k > 0; --k)
            b[i++] = j;
}
 
// Функция быстрой сортировки
template<typename T>
void quickSort(T *numbers, int left, int right)
{
    T pivot; // разрешающий элемент
    int l_hold = left; //левая граница
    int r_hold = right; // правая граница
    pivot = numbers[left];
    while (left < right) // пока границы не сомкнутся
    {
        while ((numbers[right] >= pivot) && (left < right))
            right--; // сдвигаем правую границу пока элемент [right] больше [pivot]
        if (left != right) // если границы не сомкнулись
        {
            numbers[left] = numbers[right]; // перемещаем элемент [right] на место разрешающего
            left++; // сдвигаем левую границу вправо 
        }
        while ((numbers[left] <= pivot) && (left < right))
            left++; // сдвигаем левую границу пока элемент [left] меньше [pivot]
        if (left != right) // если границы не сомкнулись
        {
            numbers[right] = numbers[left]; // перемещаем элемент [left] на место [right]
            right--; // сдвигаем правую границу вправо 
            kol++;
        }
    }
    numbers[left] = pivot; // ставим разрешающий элемент на место
    pivot = left;
    left = l_hold;
    right = r_hold;
    if (left < pivot) { // Рекурсивно вызываем сортировку для левой и правой части массива
        quickSort(numbers, left, pivot - 1);
    }
    if (right > pivot) {
        quickSort(numbers, pivot + 1, right);
    }
}
 
template<typename T, typename F = void(T*, const int &)>
float testSortDuration(T *Array, const &N size, F *Func)
{
    float begin(clock());
    sortFunction(Array, N, );
    return clock() - begin;
}
 
template<typename T>
void CopyArray(const int &n, const T *arr1, T *arr2)
{
    for (int i(0); i < n; ++i)
        arr2[i] = arr1[i];
}
 
bool IsMPow(int n)
{
    int m = 10;
    while (n > 1) {
        if (n%m) return false;
        n /= m;
    }
    return true;
}

template<typename T, typename F = void(T*, const int &)>
float testSortDuration(T *Array, const &N size, F *Func)
{
    float begin(clock());
    Func(Array, N, );
    return clock() - begin;
}

template <typename T>
void bar(T, int)
{
}
 
template <typename T>
void foo(void (T, int))
{
}
 
int main()
{
    foo(bar); // нельзя вывести тип
    foo(bar<int>); //ok
}