C++ 11 - auto和decltype

auto

auto ：
编译器通过初始值来进行类型推演，获得定义变量的类型。
auto 定义的变量必须有初始值。

个人理解：
简化书写，提高编码效率 auto 是一个很强大的工具，但有它的两面性。不加选择地随意使用。
auto，会带来代码可读性和维护性的严重下降。在使用 auto 的时候，一定要权衡好它带来的“价值”和相应的“损失”。

使用：
（1）auto推断基本类型（一条语句一个变量）

//由val_1 和val_2相加的结果可以推断出item的类型
auto item = val_1 + val_2;//item 类型初始化为val_1 + val_2相加后的类型,值为val_1+val_2相加的值。

item的类型是编译器在编译的过程中通过val_1和val_2的类型相加后推算出来的。
例如：val_1(int) + val_2(double), 那么item的类型就是double.

其他：

auto i = 42;		//i is an int
auto l = 42LL;  	//l is an long long
auto p = new foo(); //p is a foo*

（2）auto推断基本类型（一条语句多个变量）

int i = 3;
auto a = i,&b = i,*c = &i;//正确: a初始化为i的副本,b初始化为i的引用,c为i的指针.
auto sz = 0, pi = 3.14;//错误,两个变量的类型不一样。

auto在一个语句中声明多个变量：
因为一个声明语句只能有一个基本数据类型，所以该语句所有变量的初始基本数据类型都必须是一样的。在这里一定要区别数据类型和类型修饰符。

（3）声明或定义函数时作为函数返回值的占位符，需要与关键字 decltype 一起使用。（C++11）

auto不能用来声明函数的返回值。如果函数有一个尾随的返回类型时，auto是可以出现在函数声明中返回值位置。这种情况下，auto并不是告诉编译器去推断返回类型，而是指引编译器去函数的末端寻找返回值类型。
在下面这个例子中，函数返回值类型是用在T、U类型变量上的返回值类型。

template<class T, class U> 
auto add(T t, U u) -> decltype(t + u)
{
    return t + u;
}

注：
后续内容会解释下面的概论：
编译器推断出来的auto类型有时候会跟初始值的类型并不完全一样,编译器会适当的改变结果类型使得其更符合初始化规则。

（3）auto推断与引用

如我们熟知的，使用引用其实是使用引用的对象，特别当引用被用作初始值的时候，真正参与初始化的其实是引用对象的值。
此时编译器以引用对象的类型作为auto的类型：

int i = 0 ,&r = i;//定义一个整数i,并且定义r为i的应用.
auto a = r; //这里的a为为一个整数,其值跟此时的i一样.

由此，可以看出auto会忽略引用

（4）auto推断与const

int i = 0;
const int ci = i, &cr = ci;  //ci 为整数常量,cr 为整数常量引用 
auto a = ci;     // a 为一个整数, 顶层const被忽略
auto b = cr;     // b 为一个整数，顶层const被忽略
auto c = &ci;    // c 为一个整数指针.
auto d = &cr;    // d 为一个指向整数常量的指针(对常量对象区地址是那么const会变成底层const)

auto一般会忽略掉顶层const，但底层const会被保留下来。

关于顶层const和底层const，参考博文

（5）如何使用auto声明引用和顶层const呢？

const auto f=ci; //ci的推演类型是int,f是const int
auto &g=ci;// g是一个绑定到ci的引用

要声明顶层const，前面要加上const关键字；
要声明引用要加上&标识符。

（6）auto和函数指针

auto f()->int (*)(int,int);//返回一个指向int（int，int）的指针
                           //int(*)(int,int)就是尾置返回类型

auto声明函数指针是通过尾置返回类型来实现的。

decltype

decltype ：
作用是选择并返回操作数的数据类型。
在此过程中，编译器只是分析表达式并得到它的类型。
分析表达式过程中不进行实际的计算表达式的值。

使用：
（1）decltype的基本使用方法

decltype(f()) sum = x;// sum的类型就是函数f的返回值类型。

在这里编译器并不实际调用f函数，而是分析f函数的返回值作为sum的定义类型。
对于decltype还有一个用途就是在c++11引入的后置返回类型。
比如：

double h(int x,float y);

可变为:

auto h(int x,float y)->decltype(x+y);
auto h(int x,float y)->double;

（2）decltype与引用、const（和auto不同）

decltype在处理顶层const和引用的方式与auto有些许不同。
如果decltype使用的表达式是一个变量，则decltype返回该变量的类型(包括顶层const和引用在内)。

const int ci = 42, &cj = ci;
 
decltype(ci) x = 0;   // x 类型为const int
auto z = ci;          // z 类型为int
 
decltype(cj) y = x;   // y 类型为const int&
auto h = cj;          // h 类型为int

decltype还有一些值得注意的地方，我们先来看看下面这段代码：

int i = 42, *p = &i, &r = i;
 
decltype(i) x1 = 0;       //因为 i 为 int ,所以 x1 为int
auto x2 = i;              //因为 i 为 int ,所以 x2 为int
 
decltype(r) y1 = i;       //因为 r 为 int& ,所以 y1 为int&
auto y2 = r;              //因为 r 为 int& ,但auto会忽略引用，所以 y2 为int
 
decltype(r + 0) z1 = 0;   //因为 r + 0 为 int ,所以 z1 为int,
auto z2 = r + 0;          //因为 r + 0 为 int ,所以 z2 为int,
 
decltype(*p) h1 = i;      //这里 h1 是int&， 原因后面讲
auto h2 = *p;             // h2 为 int.

如果表达式的内容是解引用操作，则decltype将得到引用类型。
正如我们所熟悉的那样，解引用指针可以得到指针所指对象，而且还可以给这个对象赋值。因此decltype(*p)的结果类型就是int&。

decltype和auto还有一处重要的区别：
decltype的结果类型与表达形式密切相关。
有一种情况需要特别注意：
对于decltype 所用表达式来说，如果变量名加上一对括号，则得到的类型与不加上括号的时候可能不同。如果decltype使用的是一个不加括号的变量，那么得到的结果就是这个变量的类型。但是如果给这个变量加上一个或多层括号，那么编译器会把这个变量当作一个表达式看待，变量是一个可以作为左值的特殊表达式，所以这样的decltype就会返回引用类型：

int i = 42;
 
//decltype(i)   int  类型
//decltype((i)) int& 类型

这里再指出一个需要注意的地方：
就是 = 赋值运算符返回的是左值的引用。换句话意思就是说 decltype(i = b) 返回类型为 i 类型的引用。
仔细看下面这段代码：

int main()
{
	int i = 42;
 
decltype(i = 41) x = i;
 
auto y = i;
 
auto& z = i;
 
printf("i x y z 此时为： %d %d %d %d\n", i,x,y,z);
 
i--;
 
printf("i x y z 此时为： %d %d %d %d\n", i, x, y, z);
 
x--;
 
printf("i x y z 此时为： %d %d %d %d\n", i, x, y, z);
 
y--;
 
printf("i x y z 此时为： %d %d %d %d\n", i, x, y, z);
 
z--;
 
printf("i x y z 此时为： %d %d %d %d\n", i, x, y, z);
 
return 0;
}

运行结果为：
i x y z 此时为： 42 42 42 42
i x y z 此时为： 41 41 42 41
i x y z 此时为：40 40 42 40
i x y z 此时为： 40 40 41 40
i x y z 此时为： 39 39 41 39

由上面的代码和运行结果可以看出来：
1.decltype(i = 41)中的赋值语句并没有真正的运行。
2. decltype(i = 41)返回的其实是int&，也就是说x 其实是 i 的引用。

引用：
C++11新特性— auto 和 decltype 区别和联系
C++基本概念——细数auto和decltype之间的区别