Question

我有一个名为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

}

我的问题：我如何更改我的功能以便它可以工作以及如何遍历数组？

Answer 1

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

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;

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

Answer 2

您只需要更改函数调用：

reflexive(&(one[0]), 5);

Answer 3

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

更改

reflexive(&one, 5);

要

reflexive(one, 5);

在反身方法中使用for loop。此外，将自反方法的签名更改为 -

bool reflexive(Pair[]* a, int sizeOfA)

Answer 4

Jerry的解决方案工作得很好但是这里有一个替代方案，可以避免让你传递的硬编码和/或任何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;
}

现在您可以使用任何固定大小的数组（使用原始代码）调用自反性：

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;
}

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

如何将一个结构数组传递给函数？

4 个答案: