-2

我有一个名为 Pair 的结构数组，它有很多值。如何传递这个数组并遍历它以打印出所有值？

bool reflexive(Pair* a, int sizeOfA)
struct Pair {
  int x,y;
}one[5];

int main()
{


    one[0].x = one[0].y = 1;
    one[1].x = one[1].y = 2;
    one[2].x = one[2].y = 3;
    one[3].x = one[3].y = 4;
    one[4].x = one[4].y = 5;
    reflexive(&one, 5);         // I may also need to change this line
}

bool reflexive(Pair* a, int sizeOfA){    // This is the line that i need to change
  cout << a[0].x;          // I need to iterate through array and print all values

}

我的问题：如何更改我的函数以使其正常工作以及如何遍历数组？

4

4 回答 4

2

就像您传递任何类型的数组一样。即使没有指针符号：

bool reflexive(Pair a[], int sizeOfA)   // or Pair* a
{ 
  cout << a[0].x;         
}

称呼：

reflexive(one, 5);         // or &one[0], address of first element (both equivalent)

迭代：（在函数内部）

for(int i=0;i<sizeOfA;i++)
cout<<a[i].x;

请注意，数组是通过引用传递的。另请注意，第一行中的原型缺少分号。

于 2013-10-20T21:06:39.180 回答
0

您只需要更改函数调用：

reflexive(&(one[0]), 5);
于 2013-10-20T20:59:01.033 回答
0

您忘记了第一行末尾的分号。除非您绝对确定需要它，否则还要避免使用全局变量。

改变

reflexive(&one, 5);

到

reflexive(one, 5);

并在反身方法中使用for 循环。此外，将反射方法的签名更改为 -

bool reflexive(Pair[]* a, int sizeOfA)
于 2013-10-20T20:59:35.557 回答
0

Jerry 的解决方案工作得很好，但这里有一个替代方案，可以避免您传递硬编码的 5 和/或任何 sizeof 类型表达式。此解决方案可防止数组衰减为仅指针，这就是它如何丢失有关数组大小的信息的方式。可以通过引用而不是指针传递数组来防止衰减。

如果你总是传递一个大小为 5 的数组，你可以将反射函数更改为：

bool reflexive(Pair (&a)[5])
{
    for (const auto& b : a)
        cout << b.x;
    return true;
}

可以看到，这仍然在函数声明中保留了硬编码的 5。如果你总是传递一个已知大小的数组，即在运行时不是动态大小的，可以使用模板摆脱它：

template<size_t size> bool reflexive(Pair (&a)[size])
{
    for (const auto& b : a)
        cout << b.x;
    return true;
}

现在您可以像这样使用任何固定大小的数组调用 reflexive （使用您的原始代码）：

struct Pair {
  int x,y;
}one[5];

int main()
{
    one[0].x = one[0].y = 1;
    one[1].x = one[1].y = 2;
    one[2].x = one[2].y = 3;
    one[3].x = one[3].y = 4;
    one[4].x = one[4].y = 5;
    reflexive(one);
    return 0;
}

我建议这样做是因为解开数组中元素的数量和数组本身很容易造成开发人员意外传递错误数量的元素的错误。

于 2013-10-21T02:51:36.900 回答