3

我是 C++ 的新手。为什么我们不能迭代int*，这里有什么用，&这个嵌套的基于范围的 for 是如何深入执行的？

int arr[10][3];

for (auto &i : arr)
{
    for (auto j : i)
    {
        //sth
    }
}
4

1 回答 1

6

首先，我们需要知道确切的数据类型int arr[10][3];。它是一个由 3 个数组组成的 10 个数组int。

循环通常迭代多维容器的一维，例如

for(int i = 0; i < 10; ++i)
{
    for(int j = 0; j < 3; ++j)
    {
        arr[i][j] = 0;
    }
}

第一个循环遍历10 的数组，X然后第二个循环遍历3X的数组int。

下一步是X在代码中显式使用它：

for(int i = 0; i < 10; ++i)
{
    int (&x)[3] = arr[i];  // you won't see this syntax often

    for(int j = 0; j < 3; ++j)
    {
        int &elem = x[j];
        elem = 0;
    }
}

该行int (&x)[3]声明了对3 数组的int引用，这是访问多维数组的第一级的结果arr。

我们也可以使用迭代器来编写这个例子：

for(int (*px)[3] = arr; px != arr+10; ++px)
{
    // `px` is a _pointer to an array of 3 `int`_
    // `*px` then is an _array of 3 `int`_

    for(int *pelem = *px; pelem != (*px)+3; ++pelem)
    {
        *pelem = 0;
    }
}

请注意，我在这里使用了一个功能，它将数组转换为指向其第一个元素的指针。这称为衰减：一个数组是/可以衰减为一个指针（指向该数组的第一个元素），例如

int my_arr[3];
int *p = my_arr;  // `p` now points to the first element of `my_arr`
     p = &my_arr[0]; // equivalent

对于多维数组，这变成

int arr[10][3];
int (*p)[3];    // a pointer to an _array of 3 `int`_
p = arr;        // `p` now points to the first element of `arr`, i.e.
                // the first _array of 3 `int`_

最后但同样重要的是，对于多维数组，也可以写成：

for(int *pelem = arr[0]; pelem != arr[0]+10*3; ++pelem)
{
    *pelem = 0;
}

但这仅适用于多维数组，因为它们在内存中连续布局，并且指定了多维数组的内存布局。

这对于像这样的容器是不可能的vector<vector<int>>，即使

vector<int> v = {1,2,3,4,5};
for(int* i = &v[0]; i != &v[0] + 5; ++i)
{
    *i = 0;
}

格式良好，没有未定义的行为。

同样的逻辑现在适用于基于范围的 for 循环：

for(int (&x)[3] : arr)
{
    for(int &elem : x)
    {
        elem = 0;
    }
}

使用基于范围的 for 循环的全部意义在于摆脱显式迭代器。int*是这样一个迭代器，因此没有必要在int*IMO 上进行基于范围的 for 循环。

这种嵌套的基于范围的 for 性能如何？

C++ 语言标准在 [stmt.ranged] 中定义了基于范围的 for 语句，如下所示（注意我已经简化了一点）：

for ( for-range-declaration : 表达式 ) 语句

解决为：

{
    for ( auto __begin = /*begin-expr*/,
               __end = /*end-expr*/;
          __begin != __end;
          ++__begin )
    {
        /*for-range-declaration*/ = *__begin;
        /*statement*/
    }
}

其中for-range-declaration和statement本质上是从未解析的基于范围的 for 循环中复制粘贴的。其余的（begin-expr，end-expr）有一些复杂性，这是一个简化的版本：

{
    using std::begin;
    using std::end;

    for ( auto __begin = begin(/*expression*/),
               __end = end(/*expression*/);
          __begin != __end;
          ++__begin )
    {
        /*for-range-declaration*/ = *__begin;
        /*statement*/
    }
}

我的基于范围的 for 循环示例是从

for(int (&x)[3] : arr)
{
    /*statements*/
}

至

{
    using std::begin;
    using std::end;

    for ( auto __begin = begin(arr),
               __end = end(arr);
          __begin != __end;
          ++__begin )
    {
        int (&x)[3] = *__begin;
        /*statements*/
    }
}

或者，通过解决begin/end调用：

{
    for ( int (*__begin)[3] = arr,
               __end = arr + 10;
          __begin != __end;
          ++__begin )
    {
        int (&x)[3] = *__begin;           // (A)
        /*statements*/
    }
}

标有 an 的行(A)还说明了为什么需要&在示例for (int x[3] : arr)中使用：

int arr[10][3];
int (&x)[3] = arr[0];   // well-formed
int   x [3] = arr[0];   // ill-formed for arrays

不允许直接分配原始/C 样式的数组，正如您可能从示例中知道的那样

int my_arr[10];
int my_sec_arr[10] = my_arr;  // not legal, ill-formed

这就是为什么你必须使用参考。

使用标准库等其他容器std::array，可以避免引用：

std::array<int, 10> my_arr;
std::array<int, 10> my_sec_arr = my_arr;  // well-formed

但是分配意味着复制，所以必须复制整个数组；而这里的参考不需要复制。

正如Yakk在评论中指出的那样，这并不是您的示例&中必须使用的原因，正如已解决的那样。但如您所见，将数组衰减为指针，因此您的第二次迭代失败：for (auto &i : arr)auto &i = arr[0];int (*i)[3] = arr[0];auto

for(auto i : arr)
{
    // type of `i` now is _pointer to an array of 3 `int`_
    for(auto j : i) // can't iterate over a pointer: what are the boundaries?
    {
        /* ... */
    }
}

更准确地说：您可以遍历数组，因为编译器知道数组中有多少元素；它是类型的一部分，例如数组 3int，并且编译器知道该类型。

对于指针，编译器不知道指针是指单个元素还是元素数组，在后一种情况下，它不知道该数组有多大。在任何情况下，类型都只是，例如指向int：

int my_arr[10];
int my_int;

int *p;
p = my_arr;
p = &my_int;
p = new int[25];
于 2013-07-28T12:27:48.357 回答