using（别名）和range based for

using（别名）替代typedef

关键字

using

语法

别名声明是具有下列语法的声明：

using 标识符 attr(可选) = 类型标识 ; (1)

template < 模板形参列表 >using 标识符 attr(可选) = 类型标识 ;(2)

attr(C++11) - 可选的任意数量属性的序列

标识符 - 此声明引入的名字，它成为一个类型名 (1) 或一个模板名 (2)

模板形参列表 - 模板形参列表，同模板声明

类型标识 - 抽象声明符或其他任何合法的类型标识（可以引入新类型，如类型标识中所注明）。类型标识不能直接或间接涉指标识符。注意，标识符的声明点处于跟在类型标识之后的分号处。

解释

大家都知道，在 C++ 中可以通过 typedef 重定义一个类型：

typedef unsigned int uint_t;

被重定义的类型并不是一个新的类型，仅仅只是原有的类型取了一个新的名字。因此，下面这样将不是合法的函数重载：

void func(unsigned int);void func(uint_t);  // error: redefinition

使用 typedef 重定义类型是很方便的，但它也有一些限制，比如，无法重定义一个模板。

想象下面这个场景：

typedef std::map<std::string, int> map_int_t;typedef std::map<std::string, std::string> map_str_t;

我们需要的其实是一个固定以 std::string 为 key 的 map，它可以映射到 int 或另一个 std::string。然而这个简单的需求仅通过 typedef 却很难办到。

因此，在 C++98/03 中往往不得不这样写：

    template <typename Val>    struct str_map    {        typedef std::map<std::string, Val> type;    };    // ...    str_map<int>::type map1;    // ...

一个虽然简单但却略显烦琐的 str_map 外敷类是必要的。这明显让我们在复用某些泛型代码时非常难受。

现在，在 C++11 中终于出现了可以重定义一个模板的语法。请看下面的示例：

    template <typename Val>    using str_map_t = std::map<std::string, Val>;    // ...    str_map_t<int> map1;

这里使用新的 using 别名语法定义了 std::map 的模板别名 str_map_t。比起前面使用外敷模板加 typedef 构建的 str_map，它完全就像是一个新的 map 类模板，因此，简洁了很多。

实际上，using 的别名语法覆盖了 typedef 的全部功能。先来看看对普通类型的重定义示例，将这两种语法对比一下：

    // 重定义unsigned int    typedef unsigned int uint_t;    using uint_t = unsigned int;    // 重定义std::map    typedef std::map<std::string, int> map_int_t;    using map_int_t = std::map<std::string, int>;

可以看到，在重定义普通类型上，两种使用方法的效果是等价的，唯一不同的是定义语法。

typedef 的定义方法和变量的声明类似：像声明一个变量一样，声明一个重定义类型，之后在声明之前加上 typedef 即可。这种写法凸显了 C/C++ 中的语法一致性，但有时却会增加代码的阅读难度。比如重定义一个函数指针时：

typedef void (*func_t)(int, int);

与之相比，using 后面总是立即跟随新标识符（Identifier），之后使用类似赋值的语法，把现有的类型（type-id）赋给新类型：

using func_t = void (*)(int, int);

从上面的对比中可以发现，C++11 的 using 别名语法比 typedef 更加清晰。因为 typedef 的别名语法本质上类似一种解方程的思路。而 using 语法通过赋值来定义别名，和我们平时的思考方式一致。

下面再通过一个对比示例，看看新的 using 语法是如何定义模板别名的。

    /* C++98/03 */    template <typename T>    struct func_t    {        typedef void (*type)(T, T);    };    // 使用 func_t 模板    func_t<int>::type xx_1;    /* C++11 */    template <typename T>    using func_t = void (*)(T, T);    // 使用 func_t 模板    func_t<int> xx_2;

从示例中可以看出，通过 using 定义模板别名的语法，只是在普通类型别名语法的基础上增加 template 的参数列表。使用 using 可以轻松地创建一个新的模板别名，而不需要像 C++98/03 那样使用烦琐的外敷模板。

需要注意的是，using 语法和 typedef 一样，并不会创造新的类型。也就是说，上面示例中 C++11 的 using 写法只是 typedef 的等价物。虽然 using 重定义的 func_t 是一个模板，但 func_t<int> 定义的 xx_2 并不是一个由类模板实例化后的类，而是 void(*)(int, int) 的别名。

因此，下面这样写：

void foo(void (*func_call)(int, int));void foo(func_t<int> func_call);  // error: redefinition

同样是无法实现重载的，func_t<int> 只是 void(*)(int, int) 类型的等价物。

细心的读者可以发现，using 重定义的 func_t 是一个模板，但它既不是类模板也不是函数模板（函数模板实例化后是一个函数），而是一种新的模板形式：模板别名（alias template）。

其实，通过 using 可以轻松定义任意类型的模板表达方式。比如下面这样：

template <typename T>using type_t = T;// ...type_t<int> i;

type_t 实例化后的类型和它的模板参数类型等价。这里，type_t<int> 将等价于 int。

range based for

熟悉C#或者python的人都知道在C#和python中存在一种for的使用方法不需要明确给出容器的开始和结束条件，就可以遍历整个容器。C++11吸取了他们的优点，引入了这种方法也就是基于范围的For（Range-Based-For）。

值得一说的是，如果没有range-based-for，我们还是可以遍历容器的。它是对for的扩展。

比如C98时候我们可以这样：

int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };for (int i = 0; i < 10; i++)  cout << arr[i];

或者遍历容器，这样：

std::vector<int> vec {1,2,3,4,5,6,7,8,9,10};for (std::vector<int>::iterator itr = vec.begin(); itr != vec.end(); itr++)    std::cout << *itr;

不过有了C++11，我们就可以这样：

std::vector<int> vec {1,2,3,4,5,6,7,8,9,10};for (auto n :vec)    std::cout << n; int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };for (auto n : arr)    std::cout << n;

乍一看，是不是显得代码非常简洁？确实，这可能也是为啥引入这个概念。不过我觉得range-based-for最主要的作用可能就是“一统江湖”。有了它，不管你是数组，map，vector还是其他容器，都可以用它来遍历。

下面看看它的语法以及解释：

//语法属性(可选) for ( 范围声明 : 范围表达式 ) 循环语句//解释{  auto && __range = 范围表达式 ;  for (auto __begin = 首表达式, __end = 尾表达式 ; __begin != __end; ++__begin) {    范围声明 = *__begin;    循环语句  }}

range-based-for看起来那么美好，其实在应用的时候还是要有一些需要注意的事情：

range-base-for 默认是只读遍历，也就是说下边的例子

  std::vector<int> vec {1,2,3,4,5,6,7,8,9,10};  cout << "修改前" << endl;  for (auto n :vec)    std::cout << n++;   cout << endl;  cout << "修改后" << endl;  for (auto j : vec)    std::cout << j;
// 输出：修改前12345678910修改后12345678910

这也许并不是我们想要的，如果要修改就要将遍历的变量声明为引用型。

也就是将代码改成这样：

for (auto& n :vec)    std::cout << n++;

2. 在遍历容器的时候，auto自动推导的类型是容器的value_type类型，而不是迭代器。

之前提过range-based-for的实现方式，其中有范围表达式是自动推导的

  auto && __range = 范围表达式 ;

举个例子，如果你遍历的容器是map，那么value_type是std::pair，也就是说val的类型是std::pair类型的，因此需要使用val.first,val.second来访问数据。

std::map<string, int>  map = { { "a", 1 }, { "b", 2 }, { "c", 3 } };  for (auto &val : map)    cout << val.first << "->" << val.second << endl;

此外，使用基于范围的for循环还要注意一些容器类本身的约束，比如set的容器内的元素本身有容器的特性就决定了其元素是只读的，哪怕的使用了引用类型来遍历set元素，也是不能修改器元素的，看下面例子：

set<int> ss = { 1, 2, 3, 4, 5, 6 };  for (auto& n : ss)    cout << n++ << endl;

3. 不能迭代的时候修改容器，下面的代码运行时候可能崩溃。

vector<int> vec = { 1, 2, 3, 4, 5, 6 }; int main(){  for (auto &n : vec)  {    cout << n << endl;    vec.push_back(7);  }}

由于在遍历容器的时候，在容器中插入一个元素导致迭代器失效了，因此，基于范围的for循环和普通的for循环一样，在遍历的过程中如果修改容器，会造成迭代器失效。

4. 循环陷阱

说这个问题之前，还是要把它的实现再次粘贴过来（C++17以前）：

{  auto && __range = 范围表达式 ;  for (auto __begin = 首表达式, __end = 尾表达式 ; __begin != __end; ++__begin) {  范围声明 = *__begin;  循环语句  }}

举个例子：

#include <iostream>#include <string>
using namespace std;
struct MyClass{    string text = "MyClass";
    string& getText()   {        return text;    }};
int main(){    for (auto ch : MyClass().text)    {        cout << ch;    }    cout << endl;}

输出结果就是

MyClass

但是我们把代码改成下边的样子，结果什么都不会输出，程序直接退出

    for (auto ch : MyClass().getText())    {        cout << ch;    }

为什么会出现这样的现象呢？答案就在于range-based-for实现的时候有这样一句话：

  auto && __range = 范围表达式 ;

如果“范围表达式”返回临时量，则其生存期被延续到循环结尾，如绑定到转发引用 __range 所示，要注意的是“范围表达式”中任何临时量生存期都不被延长。

for (auto& x : foo().items()) { /* .. */ } // 若 foo() 返回右值则为未定义行为

原始的例子中，range_expression是 "MyClass().text"，MyClass()是临时对象，同时 "MyClass()" 这个表达式是右值。所以，"MyClass().text" 这个表达式也是右值，"MyClass().text" 这个对象是临时对象中的一部分。所以，在 "auto && __range = range_expression;" 这个语句中，auto会被推导为 "std::string"。初始化右值引用为临时对象的一部分时，可以延长整个临时对象的生存期，在引用被销毁时临时对象才会被销毁。所以for循环可以正常执行。

但是在修改过后，range_expression是 "MyClass().getText()"。同样地，MyClass()是临时对象，"MyClass()" 这个表达式是右值。但是 "getText()" 的返回类型为 "string&"，所以，"MyClass().getText()" 这个表达式是左值。所以，在 "auto && __range = range_expression;" 这个语句中，auto会被推导为 "string &"，语句等价于 "string & __range = range_expression;" 。虽然"MyClass().getText()" 这个对象是临时对象中的一部分，但是在初始化非const的左值引用时，不会延长临时对象的生存期，所以在这个初始化语句结束的同时MyClass()这个临时对象就被销毁了，__range成为了野引用，所以后面的循环语句可能会出现内存错误。

要解决这个问题，可以利用C++20 “初始化语句”变通解决：

for (T thing = foo(); auto& x : thing.items()) { /* ... */ } // OK