我是 C++ 的新手。为什么我们不能迭代int*
,这里有什么用,&
这个嵌套的基于范围的 for 是如何深入执行的?
int arr[10][3];
for (auto &i : arr)
{
for (auto j : i)
{
//sth
}
}
首先,我们需要知道确切的数据类型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];