Błąd w konwersji? Allias typu

Hej,
Mam problem z aliasem typu, z jakiegoś powodu jakim sposobem bym nie próbował wyskakuje mi błąd: error: invalid conversion from 'bool (*)(double, double)' to 'unsigned int' [-fpermissive] sorting::mergeSort(tab3, size, bigger); i tak do każdej funkcji. Próbowałem na wiele sposobów stworzenie z Comparatora zmiennej i przypisanie funkcji bigger, czy w każdy możliwy sposób wyłuskania. Ale teoretycznie powinno i działać w takiej formie bo nazwa funkcji to przecież w końcu też wskaźnik.
Z góry dzięki za pomoc

main.cpp

#include <iostream>
#include <stdlib.h>   
#include <time.h>
#include "sort.h"

void writeTab(double * x, int size);

bool bigger(double x, double y){
    return x>y;
}

int main(){
    srand(time(NULL));
    const int size = 3000;
    double tab1[size];
    double tab2[size];
    double tab3[size];
    for(int i = 0; i<size; ++i){
        tab1[size] = rand()%1000;
        tab2[size] = rand()%1000;
        tab3[size] = rand()%1000;
    }
    sorting::bubbleSort(tab1, size, bigger);
    sorting::quickSort(tab2, size, bigger);
    sorting::mergeSort(tab3, size, bigger);
    writeTab(tab1, size);
    writeTab(tab2, size);
    writeTab(tab3, size);
}

void writeTab(double * x, int size){
    for(int i = 0; i<size; ++i){
        std::cout<<x[size]<<" ";
    }
    std::cout<<std::endl;
}

sort.h

#pragma once

namespace sorting {

/**
 * helper definition of a pointer to a function comparing two double-precision floating-point numbers
 * @return true if the numbers lhs and rhs meet the conditions defined by the function callback, false otherwise
 */
typedef bool (*Comparator)(double lhs, double rhs);

/**
 * sort array in ascending order using bubble sort algorithm
 * @param array pointer to array of double-precision floating-point numbers to be sorted
 * @param n size of array
 * @param comparator pointer to a function comparing two double-precision floating-point numbers:
 * use operator< to sort in descending order
 * use operator> to sort in ascending order
 */
void bubbleSort(double * array, unsigned int n, Comparator comparator);

/** * sort array in ascending using quick sort algorithm in indices range [lo, hi]
 * @param array pointer to array of double-precision floating-point numbers to be sorted
 * @param lo low index of array
 * @param hi high index of array
 * @param comparator pointer to a function comparing two double-precision floating-point numbers:
 * use operator> to sort in descending order
 * use operator<= to sort in ascending order
 */
void quickSort(double * array, int lo, int hi, Comparator comparator);

/**
 * sort array in ascending order using merge sort algorithm in indices range [lo, hi]
 * @param array pointer to array of double-precision floating-point numbers to be sorted
 * @param lo low index of array
 * @param hi high index of array
 * @param comparator pointer to a function comparing two double-precision floating-point numbers:
 * use operator> to sort in descending order
 * use operator<= to sort in ascending order
 */
void mergeSort(double * array, unsigned int lo, unsigned int hi, Comparator comparator);

} // namespace sorting

Jest jeszcze plik sort.cpp, ale nie będę zaśmiecał, bo definicja alliasu istnieje w sort.h, a błąd mainie.

    sorting::quickSort(tab2, size, bigger);
    sorting::mergeSort(tab3, size, bigger);

void quickSort(double * array, int lo, int hi, Comparator comparator);
void mergeSort(double * array, unsigned int lo, unsigned int hi, Comparator comparator);

bigger podajesz jako argument trzeci - hi.

Edit: swoją drogą, to C++, użyj czytelnego zapisu:

using Comparator = bool(*)(double, double);

ByleDoPrzodu napisał(a):

    for(int i = 0; i<size; ++i){
        tab1[size] = rand()%1000;
        tab2[size] = rand()%1000;
        tab3[size] = rand()%1000;
    }

totalnie legitne wypełnianie tablicy