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

在C++ 11规范中有了for-each语法，我们可以这么写：

int arr[10] = {0};
for (int i : arr)
{
	std::cout << i << std::endl;
}

对于上面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;
}

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

  我们遍历容器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";
  }
  

  这样我们就达到修改原始数据的目的了。这是使用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.8.2 自定义对象如何支持Range-based循环

介绍了这么多，如何让我们自定义的对象支持Range-based循环语法呢？为了让一个对象支持这种语法，这个对象至少需要实现如下两个方法：

//需要返回第一个迭代子的位置
Iterator begin();
//需要返回最后一个迭代子的下一个位置
Iterator end();

上面的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;
}

注意：上述代码中，迭代子Iterator是 T*，这是指针类型，本身就支持operator ++和operator !=操作，所以这里并没有提供这两个方法的实现。那么为什么迭代子要支持operator ++和operator !=操作呢？我们来看一下编译器是如何实现这种for-each循环的。

1.8.3 for-each循环的实现原理

上述for-each循环可抽象成如下公式：

for (for-range-declaration : for-range-initializer)
	statement;

C++14标准是这样解释上面的公式的：

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

在这个循环中，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将获取起始迭代子__begin和结束迭代子__end分开来写，这样这两个迭代子就可以是不同的类型了。虽然类型可以不一样，但这两种类型之间仍然要支持operator !=操作。C++17就C++14的这种改变，对旧的代码不会产生任何影响，但可以让后来的开发更加灵活。