如何将结构的成员数组作为参数传递给函数？

Question

这是我的问题：我有一个结构：

struct point
{
    int x;
    int y;
};

然后我有一个数组：

for (int i = 0;i < n;i++)
{
    arr[i].x=rand() % n + 1;
}

我将quicksort函数定义如下：

 void quicksort(int *a, int left, int right);

并且我想按X坐标对点进行排序，所以我将其称为quicksort ：

quicksort(arr.x, 0, n-1);

这是错误消息：

错误：请求'arr'中的成员'x'，这是非类类型'point [（（（unsigned int）（（（（int）n）+ -0x000000001））+ 1）]'

抱歉，如果问题太愚蠢或措辞不好，事实是我是一个新手，我真的很乐意学习更多，非常感谢您的帮助！

Answer 1

如果您始终希望按x进行排序，则可以将其硬编码到sort函数中，并只需将指针传递给要排序的数组即可：

void quicksort(point * arr, int left, int right) {
    // test points with 
    // if (arr[i].x < arr[j].x) {/* i sorts before j */}
}

quicksort(arr, 0, n-1);

要指定要排序的类成员，您需要一个指向成员的指针，而不是指针。 就像是：

void quicksort(point * arr, int point::*member, int left, int right){
    // test points with 
    // if (arr[i].*member < arr[j].*member) {/* i sorts before j */}
}

quicksort(arr, &point::x, 0, n-1);

更笼统地说，您可以按照std::sort的示例并接受任何比较函子：

template <typename RandIter, typename Compare>
void quicksort(RandIter begin, RandIter end, Compare compare) {
    // test points with 
    // if (compare(*it1, *it2)) {/* *it1 sorts before *it2 */}
}

quicksort(arr, arr+n, 
    [](point const &lhs, point const &rhs) {return lhs.x < rhs.x;});

当然，除非您正在学习如何实现排序算法，否则只需使用std::sort 。

Answer 2

quicksort(arr,0,n-1);

然后在quicksort ，尝试比较arr[i].x

Answer 3

您的代码有一些问题。
1. quicksort接受int *，但是您尝试传递int值x
2.您尝试传递int，但实际上调用了一个未定义的变量arr.x

您需要做的是以＆arr [i] .x的形式调用，但是要完成所需的操作，您可能希望将整个结构作为指针传递。

Answer 4

您需要传递arr作为参数，因为这是要排序的数组。 arr.x是没有意义的。 您没有将字符串"arr.x"作为参数传递，该参数可以某种方式解释为对x字段进行排序-当编译器看到此参数时，它正在寻找arr的x元素，该元素不存在，如错误消息提示-只有arr的元素（例如arr[0] ）具有x元素（作为arr[0].x访问）。

Answer 5

假设这是出于学术目的（为什么您还要声明自己的排序算法，而不是使用已使用自定义比较器实现的算法之一），则可以通过以下几种方法来做到这一点：

排列

std::array<point, 10> myArray; // declares an array of size 10 for points
template<size_t N>
void quicksort(std::array<point, N>& arr, ...)
{
    // implement sort operating on arr
}

向量

std::vector<point> myVector; // declares a dynamic array/vector of points
void quicksort(std::vector<point>& arr, ...)
{
    // implement sort operating on arr
}

如果出于某种令人敬畏的原因，您希望将其保留在C中：

遗产

const size_t SIZE = 10;
point arr[SIZE]; // declare an array of 10 points
void quicksort(point* p, const size_t n, ...)
{
    // implement sort operating on elements in p passing in SIZE for n
}

Answer 6

我宁愿将该函数定义为：

 void quicksort(void *a,int left,int right, size_t size, int (*fp)(void*,void*));

size是一个数组元素的大小， fp是一个比较函数，如果两个参数相等，则返回true。 现在您可以将调用传递为：

quicksort(arr,0,n-1,sizeof(arr)/sizeof(arr[0]), compare);

函数比较类似于：

int compare(void* a, void* b) { return *((int*)a) >= *((int*)b); }  

我认为其余功能的实现都是微不足道的。

Answer 7

（几乎）绝对不要在您确实想要将指针传递给对象时通过将指针传递给成员来欺骗系统。 按照Grijesh的建议去做。 通过成员会导致可怕的副作用。 例如，无论哪个是X的，哪个是Y的，quicksort都将所有整数排序在一起。 在较温和的情况下，您可能会得到错误的比较标准，并且通常很难调试效果，例如错误的指针优化。 只要对编译器老实说，如果需要传递对象指针，则传递对象指针。 很少有例外，主要与底层系统编程有关，在底层系统编程中，函数调用的“另一端”将无法处理该对象。