C++11新特性之auto&decltype
C++11中引入了auto&decltype关键字实现类型推导，通过这两个字可以方便的获取复杂的类型还可以简化代码，提高编码效率。
auto关键字
auto类型推导
C++98/03中一直就有auto关键字了，只不过在C++98/03中auto关键字用于标识具有自动存储期的局部变量，它的作用并不大，在实际的编码过程中我们基本没有用过auto关键字，比如
auto int i = 0; //在C++98/03中 它的定义和int i = 0;是一样一样的，因此通常为了方便我们都省略了auto关键字，与之相对应的是
static int i = 0; //标识i是一个静态类型，存储在堆的全局数据区。
在C++11中auto关键字被重新利用了，用作类型推导，比如通常我们定义一个变量：
int i = 0; //强类型定义 改用auto关键字的话就可以 auto i= 20;这样定义了，我们就不需要关系对于每个值定义成什么类型，编译器自动会去根据初始化表达式的值的类型去推导变量的具体类型，因此也就意味着，编译器要推导出变量的类型，那么该变量就必须初始化，否则会编译失败。
看下面auto的一些基本用法：
auto x = 5; //OK:x是int类型
auto pi = new auto(1); //OK:pi 是int *类型
const auto *v = &x, u = 6; //OK:V是const int *类型
static auto y = 0.0; //OK:y是double类型
auto int r; //error 无法通过编译
auto s; //error 无法通过编译使用VC2013 IDE在main返回之前打个断点，可以再VC的local窗口看到变量的类型，如下：
因此，由上可知，auto不能代表一个实际的类型声明，如s编译错误，仅仅是用作类型声明的一个占位符，在编译期间，编译器会根据后面初始化值的具体类型替换auto占位符。
auto的推导规则
下面通过一组例子我们来看一下编译器在编译器间是如何推导出变量的具体类型的。
int x = 0;
auto *a = &x; //a的类型是int*,auto被推导为int
auto b = &x; //b的类型int*， auto被推导为int*
auto &c = x; //c -> int的引用，auto被推导为int
auto d = c; //d -> int auto被推导为int
const auto e = x; //e -> int auto 被推导为int
auto f = e; //f -> int auto被推导为int
const auto & g = x; //g ->const int &
auto &h = g; //h -> const int &
上面的例子可以看出。a，c的推导结果比较见到，b说明b不声明为指针也可以推导出b为指针类型，需要注意的是：
1、d的推导结果说明当表达式是一个引用类型的时候，auto会把引用类型抛弃，直接推导成原始类型int.
2、f的推导结果说明，当表达式是一个带cv限定符时，auto会把cv限定符也就是const抛弃，推导成non-const的int.
3、gh的结果说明，当auto和引用类型想结合时编译器在推导时保留表达式的cv限定符。
因此可以得到如下两条auto的推导规则：
1、当不声明为指针和引用是，auto的推导结果类型将抛弃表达式的引用和CV限定符。如上面的d,f.
2、当声明为指针或引用时，auto推导结果将保留表达式的的cv属性，如上面的g;
auto的限制
请看如下代码示例：
void func(auto a = 1){}; //error: auto不能用于函数形参，哪怕是带默认参数的形参
struct MyStruct
{
auto var = 1; //error: auto不能修饰类或者结构体中的非静态成员
static auto var2 = 2;
};
template
struct Bar{};
int _tmain(int argc, _TCHAR* argv[])
{
int arr[10] = { 0 };
auto a = arr; //OK: a ->int *
auto r[10] = arr; //error : auto不能定义数组
Bar bar;
Bar bb = bar; //error: auto 不能作为模板参数
return 0;
}
1、auto不能作为函数参数。
2、auto不能修饰类或者结构体中的非静态成员变量
3、auto不能定义数组
4、auto不能推导出模板参数
需要注意的是在auto a = arr中auto被推导出的类型是int*类型
需要注意的是在auto a = arr中auto被推导出的类型是int*类型
auto的使用
说了这么多，那么该什么时候使用auto以及如何使用auto呢？
1、在C++1前，我们要使用一个STL容器，要遍历容器内的元素的时候通常会这样写
std::map m_map;
//add element to map
std::map::iterator it = m_map.begin();
for (; it != m_map.end(); it++)
{
//dosomething
} std::map m_map;
//add element to map
for (auto it = m_map.begin(); it != m_map.end(); it++)
{
//dosomething
}
2、很多时候我们不知道给变量定义声明类型，比如下面代码所示：
class A
{
public:
static int Get()
{
return 0;
}
};
class B
{
public:
static char* Get()
{
return "abcdefg";
}
};
template
void func(void)
{
auto val = T::Get();
//....
}
int _tmain(int argc, _TCHAR* argv[])
{
func();
func();
return 0;
}
以上示例仅说明auto的一些基本的使用方法，更多的使用方法需要各位码农在编码中灵活应用。
decltype关键字
如何获取表达式的类型
前面讲的auto，用于通过一个表达式在初始化时期确定变量的具体类型，auto修饰的变量必须初始化，也即是必须得定义变量，如果不需要或者不能定义变量，却想要得到类型该怎么办呢？
C++11新增了一个关键字decltype，用于在编译时期推导出一个表达式的类型，而不用初始化，其语法格式有点像sizeof：
decltype(expr)
于sizeof一样，decltype推导表达式类型也是在编译时期就完成的，并不会真正的计算表达式的值。
下面列出了decltype的一些基本的用法：
int x = 0;
decltype(x) y = 1; //y -> int
decltype (x + y) z = 0; //z -> int
const int & i = x;
decltype(i) j = y; //j -> const int &
const decltype(z) *p = &z; // p -> const int *
decltype(z) *pi = &z; //pi -> int *
decltype(pi) *pp = &pi //pp -> int **
y,z的结果表明，decltype可以根据表达式直接推导出它的类型本身，这个跟auto很像，可是又是不同，auto必须根据初始化值的类型来推导变量的类型，若想要类型却不想定义变量，auto就不适用了。j表明decltype关键字在类型推导的时候可以保留表达式的引用和CV限定符，不会像auto那样当表达式不是指针和引用时会抛弃引用和CV限定符，p和pi说明decltype可以跟auto一样加上引用指针和CV限定符，，pp则说明当表达式是一个指针的时候，decltype仍然推导出表达式的实际类型，之后再结合pp定义是的指针标记，得到pp是一个实际的二维指针，总之记住一句话，decltype永远推导出表达式的实际类型，不管你定义时是不是加了指针或者引用标记。
decltype的推导规则
decltype(expr)的推导规则如下：
1、expr是标识符，类访问表达式，decltype(expr)和expr的类型保持一致。
2、expr是函数调用，decltype(expr)和返回值类型一致。
3、expr是一个左值，则decltype(expr)是expr类型的左值引用，否则和expr类型一致。
下面分别对上面三种情况依次讨论：
（1）expr是标识符表达式或者是类访问表达式
class Foo
{
public:
static const int number = 0;
int x;
};int _tmain(int argc, _TCHAR* argv[])
{
int n = 0;
volatile const int &x = n;
decltype(n) a = n; //a -> int
decltype(x) b = n; //b -> volatile const int &
decltype(Foo::number) c = 0; //const int
Foo foo;
decltype(foo.x) d = 0; //d ->int 类访问表达式
return 0;
}
由上面的例子可见，变量a b c保留的表达式的所有属性（包括CV属性和引用属性），根据推导规则1对于表示服表达式，decltype的推导结果和expr保持一致，而d是一个类访问表达式，也符号推导规则1，因此推导结果也和expr标尺一致。
（2）expr是一个函数调用
看下面一个例子：
int& func_r(void); //返回值类型是一个左值
int && func_rr(void); //返回值类型是一个右值
int func(void); //返回值类型是一个纯右值
const int& func_cint_r(void); //左值
const int && func_cint_rr(void);//右值
const int func_cint(void); //纯右值
int _tmain(int argc, _TCHAR* argv[])
{
int x = 0;
decltype(func_r()) a1 = x; //a1 -> int &
decltype(func_rr()) b1 = 0; //b1 -> int &&
decltype(func()) c1 = 0; //c1 -> int
decltype(func_cint_r()) a2 = x; //a2 -> const int&
decltype(func_cint_rr()) b2 = 0; //b2 -> const int &&
decltype(func_cint()) c2 = 0; //c2 -> int
return 0;
}
（3）带括号的表达式和加法运算表达式
struct Foo{ int x; };
const Foo foo = Foo();
decltype(foo.x) a = 0; //a -> int
decltype((foo.x)) b = a; // b-> const int &
int n = 0, m = 0;
decltype(n + m) c = 0; //c -> int
decltype(n += m) d = c; //d -> int &
a/b的结果仅相差一对括号，但是得到的类型确实不同的，a的结果很直接，根据推导规则1，a的类型就是foo.x的类型，然而b的类型不适合推导规则1,2，由于foo.x是一个左值，因此括号表达式也是一个左值，根据推导规则3得到的推导结果是一个左值引用，而由于foo的定义是const Foo，因此decltype的推导结果就是const int &，同样n+=m也是一个左值，因此得到的推导结果是int&。
decltype的实际应用
decltype的应用多出现在泛型编程中，考虑如下的使用场景：
template
class Foo
{
typename ContainerT::iterator _it;
public:
void func(ContainerT& container)
{
it = container.begin();
}
//...
};
int _tmain(int argc, _TCHAR* argv[])
{
typedef const std::vector(int) container_t;
container_t arr;
Foo foo;
foo.func(arr);
return 0;
} template
class Foo
{
decltype(ContainerT::begin()) _it;
public:
void func(ContainerT& container)
{
it = container.begin();
}
//...
};
int _tmain(int argc, _TCHAR* argv[])
{
typedef const std::vector(int) container_t;
container_t arr;
Foo foo;
foo.func(arr);
return 0;
} 这样不仅可以用于普通的迭代器类型也使用与任何一种迭代器类型，不需要去匹配不同的迭代器类型而对模板做特化处理，是不是方便多了？
aoto和decltype结合使用--返回类型后置语法
在泛型编程中，可能需要通过参数的运算来得到返回值的类型，考虑下面的场景：template
R add(T t, U u)
{
return t + u;
}
int _tmain(int argc, _TCHAR* argv[])
{
int a = 1; float b = 2.0;
auto c = add(a, b);
return 0;
} template < typename T, typename U>
decltype(t+u) add(T t, U u)
{
return t + u;
}template < typename T, typename U>
decltype(T()+U()) add(T t, U u)
{
return t + u;
}template < typename T, typename U>
decltype((*(T*)0)+ (*(U*)0) add(T t, U u)
{
return t + u;
}
利用返回值类型后置语法改写上面的add函数：
template < typename T, typename U>
auto add(T t, U u) -> decltype(t+u)
{
return t + u;
}
int _tmain(int argc, _TCHAR* argv[])
{
int a = 1; float b = 2.0;
auto c = add(a, b);
return 0;
}
代码可读性系不系变的很好了啊？哈哈
至此，C++中auto和decltype的用法介绍完毕，希望看了这篇文章的读者能够熟练使用auto和decltype，学习编程的最重要的手段就是写代码，不写代码只看的话永远学不会编程。
参考资料：《深入应用C++11 代码优化与工程机应用》