1.8 Range-based 循环语法
# 1.8.1 Range-based循环语法介绍
大多数语言都支持for-each语法遍历一个数组或集合中的元素，C++ 11中才支持这种语法，可谓姗姗来迟。在C++ 98/03规范中，对于一个数组int arr[10]，如果我们想要遍历这个数组，只能使用递增的计数去引用数组中每个元素：
int arr[10] = {0};
for (int i = 0; i < 10; ++i)
{
std::cout << arr[i] << std::endl;
}
2
3
4
5
在C++ 11规范中有了for-each语法，我们可以这么写：
int arr[10] = {0};
for (int i : arr)
{
std::cout << i << std::endl;
}
2
3
4
5
对于上面auto关键字章节遍历std::map，我们也可以使用这种语法：
std::map<std::string, std::string> seasons;
seasons["spring"] = "123";
seasons["summer"] = "456";
seasons["autumn"] = "789";
seasons["winter"] = "101112";
for (auto iter : seasons)
{
std::cout << iter.second << std::endl;
}
2
3
4
5
6
7
8
9
10
for-each语法虽然很强大，但是有两个需要注意的地方：
for-each中的迭代器类型与数组或集合中的元素的类型完全一致，而原来使用老式语法迭代stl容器（如 std::map）时，迭代器是类型的取地址类型。因此，在上面的例子中，老式语法中，iter是一个指针类型（std::pair<std::string, std::string>*），使用iter->second去引用键值；而在for-each语法中，iter是数据类型（std::pair<std::string, std::string>），使用iter.second直接引用键值。
for-each语法中对于复杂数据类型，迭代器是原始数据的拷贝，而不是原始数据的引用。什么意思呢？我们来看一个例子：
std::vector<std::string> v; v.push_back("zhangsan"); v.push_back("lisi"); v.push_back("maowu"); v.push_back("maliu"); for (auto iter : v) { iter = "hello"; }1
2
3
4
5
6
7
8
9我们遍历容器v，意图将v中的元素的值都修改成“hello”，但是实际执行时我们却达不到我们想要的效果。这就是上文说的for-each中的迭代器是元素的拷贝，所以这里只是将每次拷贝修改成“hello”，原始数据并不会被修改。我们可以将迭代器修改成原始数据的引用：
std::vector<std::string> v; v.push_back("zhangsan"); v.push_back("lisi"); v.push_back("maowu"); v.push_back("maliu"); for (auto& iter : v) { iter = "hello"; }1
2
3
4
5
6
7
8
9这样我们就达到修改原始数据的目的了。这是使用for-each比较容易出错的地方，对于容器中是复杂数据类型的场景，我们应该尽量使用这种引用原始数据的方式，以避免复杂数据类型不必要的调用拷贝构造函数的开销。
class A { public: A() { } ~A() = default; A(const A& rhs) { } public: int m; }; int main() { A a1; A a2; std::vector<A> v; v.push_back(a1); v.push_back(a2); for (auto iter : v) { //由于iter是v中的元素的拷贝，所以每一次循环，iter都会调用A的拷贝构造函数生成一份 //实际使用for-each循环时应该尽量使用v中元素的引用，减少不必要的拷贝函数的调用开销 iter.m = 9; } return 0; }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 1.8.2 自定义对象如何支持Range-based循环
介绍了这么多，如何让我们自定义的对象支持Range-based循环语法呢？为了让一个对象支持这种语法，这个对象至少需要实现如下两个方法：
//需要返回第一个迭代子的位置
Iterator begin();
//需要返回最后一个迭代子的下一个位置
Iterator end();
2
3
4
上面的Iterator是自定义数据类型的迭代子类型，这里的Iterator类型必须支持如下三种操作（原因下文会解释）：
operator++ （即自增）操作，即可以自增之后返回下一个迭代子的位置；
operator != （即判不等操作）操作；
operator* 即解引用（dereference）操作。
下面是一个自定义对象支持for-each循环的例子：
#include <iostream>
#include <string>
template<typename T, size_t N>
class A
{
public:
A()
{
for (size_t i = 0; i < N; ++i)
{
m_elements[i] = i;
}
}
~A()
{
}
T* begin()
{
return m_elements + 0;
}
T* end()
{
return m_elements + N;
}
private:
T m_elements[N];
};
int main()
{
A<int, 10> a;
for (auto iter : a)
{
std::cout << iter << std::endl;
}
return 0;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
注意：上述代码中，迭代子Iterator是 T*，这是指针类型，本身就支持operator ++和operator !=操作，所以这里并没有提供这两个方法的实现。那么为什么迭代子要支持operator ++和operator !=操作呢？我们来看一下编译器是如何实现这种for-each循环的。
# 1.8.3 for-each循环的实现原理
上述for-each循环可抽象成如下公式：
for (for-range-declaration : for-range-initializer)
statement;
2
C++14标准是这样解释上面的公式的：
auto && __range = for-range-initializer;
for ( auto __begin = begin-expr, __end = end-expr; __begin != __end; ++__begin )
{
for-range-declaration = *__begin;
statement;
}
2
3
4
5
6
在这个循环中，begin-expr返回的迭代子__begin需要支持自增操作，且每次循环时会与end-expr返回的迭代子__end做判不等比较，在循环内部，通过调用迭代子的解引用（*）操作取得实际的元素。这就是上文说的迭代子对象需要支持operator++、operator !=和operator* 的原因了。
但是上面的公式中，在一个逗号表达式中auto __begin = begin-expr, __end = end-expr;由于只使用了一个类型符号auto导致起始迭代子__begin和结束迭代子__end是同一个类型，这样不太灵活，在某些设计中，可能希望结束迭代子是另外一种类型。
因此到了C++17标准时，要求编译器解释for-each循环成如下形式：
1 auto && __range = for-range-initializer;
2 auto __begin = begin-expr;
3 auto __end = end-expr;
4 for ( ; __begin != __end; ++__begin ) {
5 for-range-declaration = *__begin;
6 statement;
7 }
2
3
4
5
6
7
看到了吧，代码行2和3将获取起始迭代子__begin和结束迭代子__end分开来写，这样这两个迭代子就可以是不同的类型了。虽然类型可以不一样，但这两种类型之间仍然要支持operator !=操作。C++17就C++14的这种改变，对旧的代码不会产生任何影响，但可以让后来的开发更加灵活。