1. decltype关键字
（1）auto所修饰的变量必须被初始化，编译器才能通过初始化来确定auto所代表的类型，即必须先定义变量。
（2）decltype可以在编译期推导出一个变量或表达式的结果类型（但不会真正计算表达式的值），并且使用这个结果定义新的变量。
【实例分析】获取表达式的类型
//2.1.cpp
#include <iostream> using namespace std; int main() { 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&，保留cv和引用属性 const decltype(z)* p = &z; //p: const int*， //decltype(z)*在z的类型基础上加个* //const auto* p = &z; //p: const int*,此处auto*中的*是冗余的 //相当于const auto p = &z; decltype(z)* pi = &z; //pi: int* decltype(pi)* pp = π //在pi类型的基础上加个*，即pp:int** return 0; }
2.decltype(exp)的推导规则（依序判断）
（1）规则1：如果exp是一个简单的标记符表达式或者类成员访问表达式，则decltype(exp)的类型就是exp的类型，包含的cv修饰符也不会丢失。（注意，当exp是一个被重载的函数则编译不过）。
①标记符及标记符表达式：标记符——除去关键字、字面量等标记之外、由程序自定义的标记（token）都是标记符（identifier）。而由单个标识符对应的表达式就是标记符表达式。
②如，int arr[4]中arr是一个标记符表达式，但arr[3]+0,arr[3]都不是标记符表达式。同理，int a，a是一个标记符表达式，而(a)或a+1都不是标记符表达式，其中(a)是一个左值表达式，而a+1是个右值表达式。、
（2）规则2：如果exp不是简单的标记符表达式，则必是xvalue（将亡值，右值中的一种。如std::move返回值、T&&函数返回值）、prvalue（纯右值：如非引用返回的对象、表达式产生的临时对象）、 lvaue（左值）三者之一。（注意cv修饰符可能会丢弃！）
①if exp==>lvalue then decltype(exp) ==>T& (假设exp的类型为T)
②if exp==>prvalue then decltype(exp) ==>T （重要提示：对于纯右值而言，只有类类型可以保留cv限定符，其它类型则会丢失cv限定）
③if exp==>xvalue then decltype(exp) ==>T&&
（3）规则3：如果exp被加上括号，则decltype不再认为exp是个简单的标识符表达式，然后按照规则2推理。
【实例分析】decltype的推导规则
2.2.cpp
#include <iostream> using namespace std; const int g_ci = 0; const int& g_ri = g_ci; const int foo(int){ return 0; } const int bar(int){ return 0; } class test { public: test& operator=(const test& rhs) { var1 = rhs.var1; return *this; } const double foo(int){return 0;} const double bar(int){return 0;} int var1 = 0; const double var2 = 0; static const int n = 0; }; int arr[10]; int&& g_rr=0; //g_rr: int&&(纯右值) int* ptr = arr; test t; const int& foo2(int){ static int kk; return kk; } const test testfunc(){ //return test(); } int main() { ////////////////////////////////////////////////////////////////////////////////////// //规则1：简单标记符表达式和类成员表达式 decltype(g_ci) ci = 0; //ci: const int; decltype(g_ri) ri = ci; //ri: const int&; decltype(arr) ar = {1,2,3,4,5}; //ar: int[5] decltype(foo)* pfbar = bar; //pfbar：const int (*)(int)，函数指针 decltype(&foo) pfbar2 = bar; //pfbar2类型与pfbar相同 decltype(test::foo) ptestbar = test::bar; //pftestbar: const double (test::*)(int); (t.*ptestbar)(123);//函数调用 decltype(&test::foo) ptestbar2 = &test::bar; //pftestbar2类型与pftestbar相同 (t.*ptestbar2)(123);//函数调用 decltype(test::var1) tvar1 = 0; //tvar1: int decltype(t.var1) tv1 = 0; //tv1: int decltype(&test::var1) ptv1 =&test::var1; //ptv1: int test::*,可t.*ptv1=2方式来访问。 decltype(test::var2) tvar2 = 0.0; //tvar2: const double decltype(t.var2) tv2 = 0.0; //tv2: const double; decltype(&test::var2) ptv2 =&test::var2; //ptv2: const double test::* decltype(t.n) tn = 0; //tn: const int; ////////////////////////////////////////////////////////////////////////////////////// //规则2：lvalue,xvalue,pvalue表达式规则 //如果一个表达式不是“简单id-expression”，则e必是三者之一. //IF e ==> lvalue THEN decltype(e) ==> T& //IF e ==> prvalue THEN decltype(e) ==> T //重要提示：e为普通类型时，推导结果cv丢失。e为类类型时则保留cv //IF e ==> xvalue THEN decltype(e) ==> T&& //函数调用，取返回值类型 decltype(foo(123)) foo1 = 0; //foo1: int，函数调用，返回值为纯右值，cv被丢弃。 foo1 = 1; //编译通过，证明foo1的const属性被丢弃 decltype(t.foo(123)) tfoo = 0.0; //tfoo: double，返回值为pvalue，cv丢失。 decltype(foo2(123)) lfoo = 0; //lfoo: const int&, 返回值是左值，cv保留 //lfoo = 2; //编译不通过，因为lfoo具有const属性。 int i=0; int& j=i; decltype(++i) i1 = j; //i1: int&，即左值引用，因为++i的最后一步返回i，所以结果是左值。 decltype(i++) i2 = 0; //i2: int,即纯右值，因为i++的最后一步是自增的结果，其结果是纯右值。 decltype(++j) j1 = i; //j1: int& decltype(j++) j2 = 0; //j2: int decltype(std::move(i)) i3 = 0; //i3：int&&。因为i被move为xvalue。 int m=0,n=0; decltype(m+n) mn = 0; //mn: int decltype(n +=m) mn2 = m;//mn2: int&。因为n+=m的最后一步赋值并返回n，这个的结果是左值。 decltype(arr[3]) ar3 = m; //ar3: int&，因为arr[3]可以被赋值，是个左值 decltype(*ptr) ptri = m; //ptri: int&，因为*ptr可以被赋值，是个左值。 decltype("string") str = "string"; //str: const char(&)[7],因为字符串字面量为左值。 ////////////////////////////////////////////////////////////////////////////////////// //规则3：带括号表达式规则 decltype((i)) i4 = j; //i4: int&。因为，i是个表达式，(i)也是个(左值)表达式。 decltype((foo(123))) foo3 = 0; //foo3: int。因为foo函数的返回值为const int类型，加括号后表达式类型 //仍为const int类型，是一个prvalue。故推导结果为int foo3 = 1; //编译通过，表示foo3丢弃了const属性 decltype((testfunc())) tfunc; //tfunc: const test，因为testfunc函数返回值为const test类型，是一个prvalue。 //加括号后的表达式仍为prvalue，但由于是类类型，故要保留const属性。 cout <<is_const<decltype(tfunc)>::value<<endl; //输出1，表示tfunc保留了const属性。 //decltype((t.var1)) tv; //tv: int&。因为t.var1是个左值。推导结果为左值引用，即int&。但该行会产生编译错误， //因为声明引用的同时，必须初始化 cout <<is_lvalue_reference<decltype((t.var1))>::value<<endl; //输出1，是一个左值引用 return 0; }
3.cv限制符的继承与冗余
|
差异 |
auto |
decltype |
|
const volatile |
①auto var(一般声明时)会可能舍弃cv。 ②auto& var或auto* var（带引用或指针时）时，会保留cv属性 |
一般会保留cv限定符（注意，如果表达式为纯右值时，则可能丢失cv，见前面的推导规则） |
|
引用 int& b = a |
①auto var = b //var:int，会舍弃引用 ②auto& var =a //var：int&，要使auto变量成为另一个变量的引用，必须使用auto& |
保留引用，如 decltype(b) c=a; //c:int& decltype(a)& c=a;//c:int& |
|
指针 int*p = &a |
auto* var=p;//var: int*，注意看的是初始化表达式的类型，auto*中的*是冗余的，会被忽略掉（但注意会保留CV）。与auto var=p的声明结果是一样的。 auto* var=&p;//var:int**，原理同上。 |
decltype(p)* pp;//pp:int**，注意，与auto*不同decltype(p)*的*指的是p的类型的指针形式。 |
【实例分析】cv继承与冗余
//2.3.cpp
#include <iostream> using namespace std; const int ci = 0; volatile int vi; struct S { int i; }; const S a = {0}; volatile S b; volatile S* p = &b; int main() { /////////////////////////////////////////////////////////// //const对象，使用decltype进行推导时，其成员不会继承const或volatile限定符 //普通对象 cout << is_const<decltype(ci)>::value << endl; //1，是const对象 cout << is_volatile<decltype(vi)>::value << endl; //1, 具有volatile属性 //类对象 cout << is_const<decltype(a)>::value << endl; //1，是const对象 cout << is_volatile<decltype(b)>::value << endl; //1, 具有volatile属性 cout << is_const<decltype(a.i)>::value << endl; //0，const属性不会继承给成员变量 cout << is_volatile<decltype(p->i)>::value << endl; //0, volatile属性不会继承给成员变量 //cv限定符的冗余：通常情况下，如果推导出的类型己经有cv属性，则冗余的符号会被忽略。 //注意，auto一般会丢弃cv，而decltype一般会保留cv。 int i = 1; int& j = i; int* p = &i; const int k = 1; decltype(i)& var1 = i; //var1: int& decltype(j)& var2 = i; //var2: int&。j中多出一个&，则冗余的&被忽略 cout << is_rvalue_reference<decltype(var2)>::value << endl;//0，var2不是右值引用，即不是int&& cout << is_lvalue_reference<decltype(var2)>::value << endl;//1，var2是左值引用，即int& //decltype(p)* var3 = &i; //var3：int**，与&i类型不匹配，编译不通过。 decltype(p)* var3 = &pl; //var3: int**。注意，decltype(p)*中的*不是冗余的！！！ auto* v3 = p; //v3: int*。注意auto*中的*是冗余的，相当于auto v3 = p; const decltype(k) var4 = 1; //var4: const int; 因为decltype(k)推导出来己带const， //所以最前面的const是冗余的。 return 0; }