如何对类数组进行排序？

Question

我已经使类具有二维数组 (4 x 4) 和二维数组中的最大值，如下所示：

class B {
public:
    int shape[4][4] = { 0 };
    int maxh = 0;

    B() {};

    void record(int module[4][4]) {
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                shape[i][j] = module[i][j];
                if (shape[i][j] > maxh) { maxh = shape[i][j]; }
            }
        }
    }
};

如果有一个类'B'数组，

B b_arr = new B[30000];

如何按最大值对类对象数组进行排序？

我尝试像下面的代码那样对数组进行排序，但出现堆栈溢出错误。

int partition(B arr[], int p, int r) {
    int i = p - 1;
    for (int j = p; j < r; j++) {
        int cri = arr[r].maxh;
        if (arr[j].maxh < cri) {
            i++;
            B tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }
    B tmp = arr[i + 1];
    arr[i + 1] = arr[r];
    arr[r] = tmp;
    return i + 1;
}


void quickSort(B arr[], int p, int r) {

    if (p < r) {
        int q = partition(arr, p, r);
        quickSort(arr, p, q - 1);
        quickSort(arr, q + 1, r);
    }
}

Answer 1

您可以为std::sort() 定义比较器：

请看下面的原型：

template< class RandomIt, class Compare >
void sort( RandomIt first, RandomIt last, Compare comp );

例如你可以这样做：

std::sort(
    /*std::begin(b_arr)*/b_arr,
    /*std::end(b_arr)*/b_arr+30000,
    [](const B& left, const B& right){
        return left.maxh < right.maxh;
    }
);

请注意，std::begin() 和 std::end() 不适用于指向动态数组的指针。在这种情况下，您必须通过添加大小来指定范围。我建议改用std::vector 或std::array。

Answer 2

如果你为类对象定义了一个比较器函数，你可以使用std::qsort：

int bArrCompare(const void* a, const void* b) {
    const B* pa = reinterpret_cast<const B*>(a);
    const B* pb = reinterpret_cast<const B*>(b);
    return (pb->maxh - pa->maxh);
}

int main()
{
    B* b_arr = new B[30000];
    //...
    std::qsort(b_arr, 30000, sizeof(B), bArrCompare);
    //...
    return 0;
}