C++ C++；：将函数从一个函数传递到另一个函数

我正在尝试实现一个快速排序算法，按照4种不同的标准之一对填充有“Movie”类型对象的数组进行排序。每个电影对象都包含排名、投票数、评级和电影名称。我还在类定义中编写了4个静态bool函数，它接受两个movie对象引用，如果第一个较小，则返回true；如果较大，则返回false

例：

bool-Movie:：GetLowerRank（const-Movie&x，const-Movie&y）{
if（x.rank

正如我所说，我正在尝试实现一种快速排序算法，它将根据用户偏好对数组进行排序。我想将4个排序函数中的一个传递给快速排序函数，类似于向量排序的工作方式。我的问题是我有两个快速排序函数，递归函数和基函数：

void quickSort(Movie array[], int min, int max, bool (*compare_function)(Movie&, Movie&)){
    if (min < max) {
        int pivot_i = (min + max)/2;
        int pivot_i2 = quickSort(array, min, max, pivot_i, compare_function);
        quickSort(array, min, pivot_i2 - 1);
        quickSort(array, pivot_i2 +1, max);
    }   
}

int quickSort(Movie array[], int min, int max, int pivot, bool (*compare_function)(Movie& a, Movie& b)){
    Movie pivot_entry = array[pivot];
    swap (array[pivot], array[max]);
    int pivot_final_index = min;
    for (int i = min; i < max; i++) {
        if(compare_function(array[i], pivot_entry)){
            swap(array[i], array[pivot_final_index]);
            ++pivot_final_index;
        }
    }
    swap(array[max], array[pivot_final_index]);
    return pivot_final_index;
}

void快速排序（电影数组[]，最小整数，最大整数，布尔（*比较函数）（电影和电影和）{
如果（最小值<最大值）{
int pivot_i=（最小+最大）/2；
int pivot_i2=快速排序（数组、最小值、最大值、pivot_i、比较函数）；
快速排序（数组、最小值、枢轴_i2-1）；
快速排序（数组，pivot_i2+1，最大值）；
}   
}
int快速排序（电影数组[]、int最小值、int最大值、int轴、bool（*比较函数）（电影与a、电影与b））{
电影透视_条目=数组[透视]；
交换（数组[pivot]，数组[max]）；
int pivot_final_index=min；
对于（int i=min；i

---

我已经尝试将函数参数添加到参数列表中，但我不知道如何让void快速排序将函数（主要是获得的）传递到实际使用它的int快速排序中。

首先简化

GetLowerRank

以

bool Movie::GetLowerRank(const Movie& x, const Movie& y) {
    return x.rank < y.rank;
}

---

第一个快速排序中的递归调用似乎是在未使用函数指针的情况下调用的：

    quickSort(array, min, pivot_i2 - 1);
    quickSort(array, pivot_i2 +1, max);

---

下面的代码使用函数指针并将编译：

注意：int已替换为Movie:

如果

Movie

仍有错误，即使是 如果没有严格必要进行验证

(1) the assignment operator and 
(2) copy constructor and 
(3) equality operator

（所有三个）都是为电影定义的（您可能已经知道这一点）

void快速排序（int数组[]，int最小，int最大，bool（*比较函数）（int&，int&））；
int快速排序（int数组[]、int最小值、int最大值、int轴、bool（*比较函数）（int&a、int&b））；
无效交换（整数数组[]，整数a，整数b）；
无效交换（整数数组[]，整数a，整数b）{
内部温度；
if（数组！=NULL）{
温度=阵列[a]；
数组[a]=数组[b]；
数组[b]=温度；
}
}
void快速排序（int数组[]，int最小值，int最大值，bool（*比较函数）（int&，int&）{
如果（最小值<最大值）{
int pivot_i=（最小+最大）/2；
int pivot_i2=快速排序（数组、最小值、最大值、pivot_i、比较函数）；
快速排序（数组、min、pivot_i2-1、compare_函数）；
快速排序（数组、pivot_i2+1、最大值、比较_函数）；
}   
}
int快速排序（int数组[]、int最小值、int最大值、int枢轴、，
布尔（*比较函数）（内部和a、内部和b））{
int pivot_entry=数组[pivot]；
交换（数组、轴、最大值）；
int pivot_final_index=min；
对于（int i=min；i

您的

void quickSort

在尝试调用它之前是否已经看到了

int quickSort

的原型？GetLowerRank函数是静态的吗？实际函数需要两个

常量电影&

和

quickSort

原型需要两个

电影&

之间存在差异。您可以保存您可以自己解决实现中的问题，并使用

std:：sort

（采用自定义谓词的重载）。是的，所有bool比较函数都是静态的。谢谢你指出差异，我已经解决了这两个问题。我知道我可以使用STL算法，但我想尝试实现它，只是为了我自己的理解和知识。

    quickSort(array, min, pivot_i2 - 1);
    quickSort(array, pivot_i2 +1, max);

(1) the assignment operator and 
(2) copy constructor and 
(3) equality operator

void quickSort(int array[], int min, int max, bool (*compare_function)(int&, int&));

int quickSort(int array[], int min, int max, int pivot, bool (*compare_function)(int& a, int& b));

void swap(int array[], int a, int b);


void swap(int array[], int a, int b) {
    int temp;
    if (array != NULL) {
        temp = array[a];
        array[a] = array[b];
        array[b] = temp;

    }

}

void quickSort(int array[], int min, int max, bool (*compare_function)(int&, int&)){

    if (min < max) {

        int pivot_i = (min + max)/2;
        int pivot_i2 = quickSort(array, min, max, pivot_i, compare_function);
        quickSort(array, min, pivot_i2 - 1, compare_function);
        quickSort(array, pivot_i2 +1, max, compare_function);
    }   
}

int quickSort(int array[], int min, int max, int pivot, 
    bool (*compare_function)(int& a, int& b)){

    int pivot_entry = array[pivot];

    swap (array, pivot, max);

    int pivot_final_index = min;

    for (int i = min; i < max; i++) {
        if(compare_function(array[i], pivot_entry)){
            swap(array, i, pivot_final_index);
            ++pivot_final_index;
        }
    }
    swap(array, max, pivot_final_index);
    return pivot_final_index;
}