编程时常常需要把表达式的值赋给变量，这就要求在声明变量的时候清楚知道表达式的类型。然而要做到这一点并非那么容易，有时候甚至根本做不到。为了解决这个问题，C++11标准引入了auto类型说明符，用它就能让编译器替我们去分析表达式所属的类型。
与原来那些只对应一种特定类型的说明符不同，auto让编译器通过初值来推算变量类型。显然，auto定义的变量必须要有初始值。
使用auto具有以下几点好处：
可靠性：如果表达式的类型发生更改（包括函数返回值发生更改的情况），它也能工作。
性能：确保将不会进行转换。
可用性：不必担心类型名称拼写困难和拼写有误。
效率：代码会变得更高效。
|
1
2
|
auto item = val1 + val2; // 由val1和val2相加的结果推断出item的类型auto i=0, *p = &i; // i是整数，p是整型指针 |
使用auto能在一条语句中声明多个变量。但是一条声明语句只能有一个基本数据类型，所以该语句中所有变量的初始基本数据类型都必须一致：
|
1
|
auto sz = 0, pi = 3.14; // Error! |
编译器推断出的auto类型有时候和初始值的类型并不完全一样，编译器会适当地改变结果类型使其更符合初始化规则，例如：
使用auto会删除引用
|
1
2
3
4
5
6
7
8
9
|
int count = 10;int& countRef = count;auto myAuto = countRef;countRef = 11;cout << count << " "; // print 11myAuto = 12;cout << count << endl; // print 11 |
你可能会认为 myAuto 是一个 int 引用，但它不是。它只是一个 int，因为输出为 11 11，而不是 11 12；如果 auto 尚未删除此引用，则会出现此情况。
const限定符
先引入一种表述：顶层const表示指针本身是个常量，底层const表示指针所指的对象是一个常量。一般auto会忽略掉顶层const，同时底层const则会保留下来，例如：
|
1
2
3
4
5
6
|
int i = 0;const int ci = i, &cr = ci;auto b = ci; // b 是一个整数（ci的顶层const特性被忽略掉）auto c = cr; // c 是一个整数（cr是ci的别名，ci本身是一个顶层const）auto d = &i; // d 是一个整型指针（整数的地址就是指向整数的指针）auto e = &ci; // e 是一个指向整数常量的指针（对常量对象取地址是一种底层const） |
如果希望推断出的auto类型是一个顶层const，需要明确指出：
|
1
|
const auto f = ci; // ci 的推演类型是int，f是const int类型 |
还可以将引用的类型设置为auto，此时原来的初始化规则仍然适用：
|
1
2
3
|
auto &g = ci; // g是一个整型常量引用，绑定到ciauto &h = 42; // Error: 不能为非常量引用绑定字面值const auto &j = 42; // OK: 可以为常量引用绑定字面值 |
切记，符号*和&只从属于某个声明，而非基本数据类型的一部分，因此初始值必须是同一类型：
|
1
2
3
|
auto k = ci, &l = i; // k是整数，l是整型引用auto &m = ci, *p = &ci; // m是对整型常量的引用，p是指向整型常量的指针auto &n = i, *p2 = &ci; // Error: i的类型是int，而&ci的类型是const int |
附上更多示例代码：
下面的声明等效。在第一个语句中，将变量j 声明为类型 int。在第二个语句中，将变量 k 推导为类型 int，因为初始化表达式 (0) 是整数
|
1
2
|
int j = 0; // Variable j is explicitly type int.auto k = 0; // Variable k is implicitly type int because 0 is an integer. |
以下声明等效，但第二个声明比第一个更简单。使用 auto 关键字的最令人信服的一个原因是简单
|
1
2
|
map<int,list<string>>::iterator i = m.begin(); auto i = m.begin(); |
使用 iter 和 elem 启动循环时
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#include <deque>using namespace std;int main(){ deque<double> dqDoubleData(10, 0.1); for (auto iter = dqDoubleData.begin(); iter != dqDoubleData.end(); ++iter) { /* ... */ } // prefer range-for loops with the following information in mind // (this applies to any range-for with auto, not just deque) for (auto elem : dqDoubleData) // COPIES elements, not much better than the previous examples { /* ... */ } for (auto& elem : dqDoubleData) // observes and/or modifies elements IN-PLACE { /* ... */ } for (const auto& elem : dqDoubleData) // observes elements IN-PLACE { /* ... */ }} |
下面的代码片段使用 new 运算符和指针声明来声明指针
|
1
2
|
double x = 12.34;auto *y = new auto(x), **z = new auto(&x); |
下一个代码片段在每个声明语句中声明多个符号。请注意，每个语句中的所有符号将解析为同一类型。
|
1
2
3
4
|
auto x = 1, *y = &x, **z = &y; // Resolves to int.auto a(2.01), *b (&a); // Resolves to double.auto c = 'a', *d(&c); // Resolves to char.auto m = 1, &n = m; // Resolves to int. |
此代码片段使用条件运算符 (?:) 将变量 x 声明为值为 200 的整数：
|
1
2
|
int v1 = 100, v2 = 200;auto x = v1 > v2 ? v1 : v2; |
下面的代码片段将变量 x 初始化为类型 int，将变量 y初始化对类型 const int 的引用，将变量 fp 初始化为指向返回类型 int 的函数的指针。
|
1
2
3
4
5
6
7
8
9
10
|
int f(int x) { return x; }int main(){ auto x = f(0); const auto & y = f(1); int (*p)(int x); p = f; auto fp = p; //...} |
