注意：C++ 2.0新特性中关键字的源码都还没看

C++2.0新特性

语言+标准库（以头文件的形式呈现）

了解编译器对 C++ 2.0的支持程度 还有几个重要网站，见STL(一)的前面

全文检索工具——grep

Dev C++ | 如何设置C++11标准

在DEV C++中选择tool 选Compiler Options

上图选settings

Variadic Templates(可变模板参数)

在C++11之前，类模板和函数模板只能含有【固定数量的模板参数】。 C++11增强了模板功能，允许模板定义中包含【0到任意个模板参数】，这就是【可变参数模板】。 可变参数模板和普通模板的语义是一样的，只是写法上稍有区别， 【声明可变参数模板】时需要在typename或class后面带上省略号“…”： template<class ... T> void func(T ... args)//T叫模板参数包，args叫函数参数包 {//可变参数模板函数 } func(); // OK：args不含有任何实参 func(1); // OK：args含有一个实参：int func(2, 1.0); // OK：args含有两个实参int和double T叫模板参数包，args叫函数参数包。 省略号“…”的作用有两个： 1、声明一个参数包，这个参数包中可以包含0到任意个模板参数 2、在模板定义的右边，可以将参数包展开成一个一个独立的参数

可变参数模板函数：

可变模板参数定义如下：

参数包的展开：

1、递归方式展开 通过递归函数展开参数包，需要提供【一个参数包展开的函数】和【一个递归终止函数】。 #include <iostream> using namespace std; //递归终止函数 void debug() { cout << "empty\n"; } //展开函数 template <class T, class ... Args> void debug(T first, Args ... last) { cout << "parameter " << first << endl; debug(last...); } int main() { debug(1, 2, 3, 4); return 0; }

递归调用过程如下：

debug(1, 2, 3, 4); debug(2, 3, 4); debug(3, 4); debug(4); debug();

通过可变参数模板实现打印函数：（奇怪？？？？）

#include <iostream> #include <stdexcept> using namespace std; void Debug(const char* s) { while (*s) { if (*s == '%' && *++s != '%') { throw runtime_error("invalid format string: missing arguments"); } cout << *s++; } } template<typename T, typename... Args> void Debug(const char* s, T value, Args... args) { while (*s) { if (*s == '%' && *++s != '%') { cout << value; return Debug(++s, args...); } cout << *s++; } throw runtime_error("extra arguments provided to Debug"); } int main() { Debug("a = %d, b = %c, c = %s\n", 250, 'm', "mike"); return 0; } 2、非递归方式展开 #include <iostream> using namespace std; template <class T> void print(T arg) { cout << arg << endl; } template <class ... Args> void expand(Args ... args) { int a[] = { (print(args), 0)... }; } int main() { expand(1, 2, 3, 4); return 0; }

expand函数的逗号表达式：(print(args), 0)， 也是按照这个执行顺序，先执行print(args)，再得到逗号表达式的结果0。 同时，通过初始化列表来初始化一个变长数组，{ (print(args), 0)… }将会展开 成( (print(args1), 0), (print(args2), 0), (print(args3), 0), etc…), 最终会创建一个元素值都为0的数组int a[sizeof…(args)]。

可变参数模板：

继承方式展开参数包：（后面这里牵扯到模板的偏特化？？？？）

可变参数模板类的展开一般需要定义2 ~ 3个类，包含类声明和特化的模板类： #include <iostream> #include <typeinfo> using namespace std; template<typename... A> class BMW{}; // 变长模板的声明 template<typename Head, typename... Tail> // 递归的偏特化定义 class BMW<Head, Tail...> : public BMW<Tail...> {//当实例化对象时，则会引起基类的递归构造 public: BMW() { printf("type: %s\n", typeid(Head).name()); } Head head; }; template<> class BMW<>{}; // 边界条件 int main() { BMW<int, char, float> car; return 0; }

模板递归和特化方式展开参数包：

#include <iostream> using namespace std; template <long... nums> struct Multiply;// 变长模板的声明 template <long first, long... last> struct Multiply<first, last...> // 变长模板类 { static const long val = first * Multiply<last...>::val; }; template<> struct Multiply<> // 边界条件 { static const long val = 1; }; int main() { cout << Multiply<2, 3, 4, 5>::val << endl; // 120 return 0; }

这个print()接受一个参数和一包参数（……表示的就是不知道多少个参数）【这里不仅个数随意，参数类型也随意】 template<typename T,typename… Types>【表示的1+其余】 当没有参数的时候会调用①的print()函数 可以帮助我们做递归，这递归的目的就是为了将参数个数一一分解 怎样分解，就是把n变成1+其他 sizeof…(arg)可以获取参数的个数

下面这两块没看懂？？？？

Space in Template Expressions

nullptr√

nullptr是为了【解决原来C++中NULL的二义性问题】而引进的一种新的类型，因为NULL实际上代表的是0。 void func(int a) { cout << __LINE__ << " a = " << a <<endl; } void func(int *p) { cout << __LINE__ << " p = " << p <<endl; } int main() { int *p1 = nullptr; int *p2 = NULL; if(p1 == p2) { cout << "equal\n"; } //int a = nullptr; //err, 编译失败，nullptr不能转型为int func(0); //调用func(int)， 就算写NULL，也是调用这个 func(nullptr); return 0; }

原生字符串字面值√

原生字符串字面值(raw string literal)使用户书写的字符串“所见即所得”。 C++11中原生字符串的声明相当简单，【只需在字符串前加入前缀，即字母R，并在引号中使用括号左右标识，】 就可以声明该字符串字面量为原生字符串了。 #include <iostream> #include <string> using namespace std; int main(void) { cout << R"(hello, \n world)" << endl; string str = R"(helo \4 \r abc, mike hello\n)"; cout << endl; cout << str << endl; return 0; }

auto√

auto的自动类型推导，用于从初始化表达式中推断出变量的数据类型。 从这个意义上讲，auto并非一种“类型”声明，而是一个类型声明时的“占位符”， 编译器在【编译时期】会将auto替换为变量实际的类型。 不要依赖auto，要会类型推到 auto的使用是在类型很长或者很复杂的时候

重点看下面的注释部分

#include <iostream> #include <vector> #include <string> using namespace std; double foo() {} void func(vector<string> & tmp) { for (auto i = tmp.begin(); i < tmp.end(); i++) { // 一些代码 } } int main() { auto x = 1; // x的类型为int auto y = foo(); // y的类型为double struct m { int i; }str; auto str1 = str; // str1的类型是struct m auto z; // err, 无法推导，无法通过编译 z = x; return 0; }

注意点(这几种无法编译的情况为啥呢？？？？)

1: auto函数参数，有些编译器无法通过编译 2: auto非静态成员变量，无法通过编译 3: auto数组，无法通过编译 4: auto模板参数（实例化时），无法通过编译 void fun(auto x =1) {} // 1: auto函数参数，有些编译器无法通过编译 struct str { auto var = 10; // 2: auto非静态成员变量，无法通过编译 }; int main() { char x[3]; auto y = x; auto z[3] = x; // 3: auto数组，无法通过编译 // 4: auto模板参数（实例化时），无法通过编译 vector<auto> x = {1}; return 0; }

标准库本身也有使用新的关键字

Uniform Initialization（统一初始化）√

初始化 类内成员初始化

class Mem { public: Mem(int i): m(i){} //初始化列表给m初始化 int m; }; class Group { public: Group(){} private: int data = 1; // 使用"="初始化非静态普通成员，也可以 int data{1}; Mem mem{2}; // 对象成员，创建对象时，可以使用{}来调用构造函数 string name{"mike"}; };

初始化列表

初始化方式如下 int a[]{1, 3, 5}; int i = {1}; int j{3}; 下面是用于结构体类型的情况 struct Person { std::string name; int age; }; int main() { Person p = {"Frank", 25}; std::cout << p.name << " : " << p.age << std::endl; } 其他一些不方便初始化的地方使用， 比如std的初始化，如果不使用这种方式，只能用构造函数来初始化，难以达到效果： std::vector<int> ivec1(3, 5); std::vector<int> ivec2 = {5, 5, 5}; std::vector<int> ivec3 = {1,2,3,4,5}; //不使用列表初始化用构造函数难以实现

防止类型收窄

【类型收窄】指的是导致**数据内容发生变化**或者**精度丢失**的隐式类型转换。 使用列表初始化可以防止类型收窄。

关于类型收窄

为什么要防止类型收窄

struct Foo { Foo(int i) { std::cout << i << std::endl; } }; Foo foo(1.2); 【以上代码在C++中能够正常通过编译】，但是传递之后的i却不能完整地保存一个浮点型的数据。 上面的示例让我们对类型收窄有了一个大概的了解。具体来说，类型收窄包括以下几种情况： 1）从一个浮点数隐式转换为一个整型数，如int i=2.2。 2）从高精度浮点数隐式转换为低精度浮点数，如从long double隐式转换为double或float。 3）从一个整型数隐式转换为一个浮点数，并且超出了浮点数的表示范围，如float x=(unsigned long long)-1。 4）从一个整型数隐式转换为一个长度较短的整型数，并且超出了长度较短的整型数的表示范围，如char x=65536。 在C++98/03中，像上面所示类型收窄的情况，编译器并不会报错（或报一个警告，如Microsoft Visual C++）。 这往往会导致一些隐藏的错误。【在C++11中，可以通过列表初始化来检查及防止类型收窄】 列表初始化防止类型收窄示例

请看上图的报错

int a = 1.1; // OK int b = { 1.1 }; // error float fa = 1e40; // OK float fb = { 1e40 }; // error float fc = (unsigned long long)-1; // OK float fd = { (unsigned long long)-1 }; // error float fe = (unsigned long long)1; // OK float ff = { (unsigned long long)1 }; // OK const int x = 1024, y = 1; char c = x; // OK char d = { x }; // error char e = y; // OK char f = { y }; // OK 上面的各种隐式类型转换中，只要遇到了类型收窄的情况，初始化列表就不会允许这种转换发生。 其中需要注意的是x、y被定义成了const int。如果去掉const限定符，那么***一个变量f也会因为类型收窄而报错

Initializer Lists（不是很懂）

不接受窄的转化 Initializer Lists可以实现参数个数不定（但是类型有说法）

由源码可知，Initializer Lists的背后就是array

clion编译器中的源码和老师的一样

Initializer Lists的使用就可以使得max和min接受任意多的参数【这就是Initializer Lists的妙用】

explicit

explicit这个关键字主要是用在构造函数身上 下面是C++ 2.0之前的用法（单一实参）

下面是C++ 2.0【之后】的用法

for循环的一种规则√

基于范围的for循环

int a[] = { 1, 2, 3, 4, 5 }; int n = sizeof(a) / sizeof(*a); //元素个数 for (int i = 0; i < n; ++i) { int tmp = a[i]; cout << tmp << ", "; } cout << endl; for (int tmp : a) { cout << tmp << ", "; } cout << endl; for (int i = 0; i < n; ++i) { int &tmp = a[i]; tmp = 2 * tmp; cout << tmp << ", "; } cout << endl; for (int &tmp : a) { tmp = 2 * tmp; cout << tmp << ", "; } cout << endl;

使用基于范围的for循环，其【for循环迭代的范围必须是可确定的】：

int func(int a[])//形参中数组是指针变量，无法确定元素个数 { for(auto e: a) // err, 编译失败 { cout << e; } } int main() { int a[] = {1, 2, 3, 4, 5}; func(a); return 0; }

静态断言

C/C++提供了调试工具assert，这是一个宏，用于在【运行阶段】对断言进行检查， 如果条件为真，执行程序，否则调用abort()。 int main() { bool flag = false; //如果条件为真，程序正常执行，如果为假，终止程序，提示错误 assert(flag == true); //#include <cassert>或#include <assert.h> cout << "Hello World!" << endl; return 0; }

【C++ 11新增了关键字static_assert】，可用于在【编译阶段】对断言进行测试。

语法： static_assert(常量表达式，提示字符串) 【注意】：只能是【常量表达式】，不能是变量 示例： int main() { //该static_assert用来确保编译仅在32位的平台上进行，不支持64位的平台 static_assert( sizeof(void *)== 4, "64-bit code generation is not supported."); cout << "Hello World!" << endl; return 0; } 静态断言的好处： 更早的报告错误，我们知道构建是早于运行的，更早的错误报告意味着【开发成本的降低】 减少运行时开销，静态断言是【编译期】检测的，【减少了运行时开销】

=default,=delete√

优秀博客

如果程序员【没有显式地为一个类定义】某个特殊成员函数，【而又需要用到】该特殊成员函数时， 则编译器会隐式的为这个类生成一个默认的特殊成员函数。 default针对的是【默认构造函数】、【析构函数】、【拷贝构造函数】和【拷贝赋值函数】 defaulted 函数特性仅适用于【类的特殊成员函数】（上面四种），且该【特殊成员函数没有默认参数】。

好处： 1. 减轻程序员的编程工作量； 2. 获得编译器自动生成的默认特殊成员函数的高的代码执行效率。

default详解

delete 为了能够让程序员【显式的禁用某个函数】， C++11 标准引入了一个新特性：deleted 函数。程序员只需在函数声明后上“=delete;”，就可将该函数禁用。 用法： 1、用于禁用类的某些转换构造函数，从而避免不期望的类型转换。 2、用来禁用某些用户自定义的类的 new 操作符，从而避免在自由存储区创建类的对象 3、必须在函数第一次声明的时候将其声明为 deleted 函数，否则编译器会报错。 （即对于类的成员函数而言，deleted 函数必须在类体里（inline）定义，而不能在类体外（out-of-line）定义。） 4、虽然 defaulted 函数特性规定了只有类的特殊成员函数才能被声明为 defaulted 函数， 【但是】 deleted 函数特性并没有此限制。非类的成员函数，即普通函数也可以被声明为 deleted 函数。 5、虽然delete让函数不能被调用。但是【函数标示符】仍是有效的，在名字查找和函数重载解析时仍会查找到该函数标示符。 如果编译器在解析重载函数时，解析结果为 deleted 函数，则会出现编译错误。 构造函数可以重载，但是拷贝构造函数不能

？？？？

Alias Template

模板模板参数

Type Alias

using[用于模板的别名]√

见下面的示例：

#include <iostream> #include <type_traits> //std::is_same using namespace std; using uint = unsigned int; typedef unsigned int UINT; using sint = int; int main() { //std::is_same 判断类型是否一致 //这个结构体作用很简单，就是两个一样的类型会返回true cout << is_same<int, sint>::value << endl; // 1 cout << is_same<uint, UINT>::value << endl; // 1 return 0; }

noexcept√

void func3() throw(int, char) //只能够抛出 int 和char类型的异常 {//C++11已经弃用这个声明 throw 0; } void BlockThrow() throw() //代表此函数不能抛出异常，如果抛出，就会异常 { throw 1; } //C++11 使用noexcept替代throw() void BlockThrowPro() noexcept //代表此函数不能抛出异常，如果抛出，就会异常 { throw 2; }

参考这篇博客

下面是std::initializer_list的默认构造函数，其中使用了noexcept。 constexpr initializer_list() noexcept : _M_array(0), _M_len(0) { } 该关键字告诉编译器，函数中不会发生异常,这有利于编译器对程序做更多的优化。 如果在运行时，noexecpt函数向外抛出了异常（如果函数内部捕捉了异常并完成处理，这种情况不算抛出异常）， 程序会直接终止，调用std::terminate()函数，该函数内部会调用std::abort()终止程序。

C++的异常处理

C++中的异常处理是在运行时而不是编译时检测的。为了实现运行时检测，编译器创建额外的代码，然而这会妨碍程序优化。 在实践中，一般两种异常抛出方式是常用的： 一个操作或者函数可能会抛出一个异常; 一个操作或者函数不可能抛出任何异常。 后面这一种方式中在以往的C++版本中常用throw()表示，在C++ 11中已经被noexcept代替。 void swap(Type& x, Type& y) throw() //C++11之前 { x.swap(y); } //下面单独使用noexcept，表示其所限定的swap函数绝对不发生异常 void swap(Type& x, Type& y) noexcept //C++11 { x.swap(y); }

有条件的noexcept

void swap(Type& x, Type& y) noexcept(noexcept(x.swap(y))) //C++11 { x.swap(y); } 它表示，如果操作x.swap(y)不发生异常，那么函数swap(Type& x, Type& y)一定不发生异常。

什么时候该使用noexcept

使用noexcept表明函数或操作不会发生异常，会给编译器更大的优化空间。 然而，【并不是加上noexcept就能提高效率】。 以下情形鼓励使用noexcept： 1、移动构造函数（move constructor） 2、移动分配函数（move assignment） 3、析构函数（destructor）。 在新版本的编译器中，析构函数是默认加上关键字noexcept的。

强类型枚举√

C++ 枚举类型详解

C++ 11引入了一种新的枚举类型，即“枚举类”，又称“强类型枚举”。 声明请类型枚举非常简单，只需要【在enum后加上使用class或struct】（声明实现）。如： enum Old{Yes, No}; // old style enum class New{Yes, No}; // new style enum struct New2{Yes, No}; // new style “传统”的C++枚举类型有一些【缺点】： 它会在一个代码区间中抛出枚举类型成员（如果在相同的代码域中的两个枚举类型具有相同名字的枚举成员，这会导致【命名冲突】）， 【它们会被隐式转换为整型，并且不可以指定枚举的底层数据类型】。 int main() { enum Status{Ok, Error}; //enum Status2{Ok, Error};//err, 导致命名冲突, Status已经有成员叫Ok, Error return 0; }

上诉的缺点在C++ 11中都获得了解决√

int main() { enum class Status {Ok, Error}; enum struct Status2{Ok, Error}; //Status flag1 = 10; // err，无法隐式转换为int类型 //Status flag2 = Ok; // err，必须使用强类型名称 Status flag3 = Status::Ok; enum class C : char { C1 = 1, C2 = 2};//指定枚举的底层数据类型 enum class D : unsigned int { D1 = 1, D2 = 2, Dbig = 0xFFFFFFF0U }; cout << sizeof(C::C1) << endl; // 1 cout << (unsigned int)D::Dbig << endl; // 编译器输出一致,4294967280 cout << sizeof(D::D1) << endl; // 4 cout << sizeof(D::Dbig) << endl; // 4 return 0; }

常量表达式√

参考博客

类的改造√

1、继承构造

C++ 11【允许派生类继承基类的构造函数】，【默认构造函数、复制构造函数、移动构造函数除外】。 #include <iostream> using namespace std; //基类 class A { public: A(int x, int y) { a = x; b = y; } protected: int a; int b; }; //派生类 class B:public A { public: //继承构造 using A::A; void display() { cout << "a = " << a << ", b = " << b << endl; } //没有增加新的成员变量 int tmp; }; int main() { //派生类对象 B obj(10, 20); obj.display(); return 0; }

上诉代码若是去掉 using A::A; 这一行，看报错信息

注意： 1、继承的构造函数【只能初始化基类中的成员变量】，不能初始化派生类的成员变量 2、如果1、基类的构造函数被声明为私有，或者2、派生类是从基类中虚继承，那么不能继承构造函数 3、一旦使用继承构造函数，编译器不会再为派生类生成默认构造函数

2、委托构造

和继承构造函数类似，委托构造函数也是C++11中对C++的构造函数的一项改进，其【目的也是为了减少程序员书写构造函数的时间】。 如果一个类包含多个构造函数，C++ 11允许在一个构造函数中的定义中使用另一个构造函数，但这必须通过初始化列表进行操作，如下： #include <iostream> using namespace std; class Test { public: //委托构造，一定要通过初始化列表方式 Test():Test(1, 'a') { } Test(int x): Test(x, 'b') { } Test(char x): Test(11, x) { } int a; char b; private: Test(int x, char y): a(x), b(y) { } }; int main() { //Test obj; // Test():Test(1, 'a') Test obj1(); cout << obj1 << endl; Test obj2('z'); cout << obj2.a << endl; cout << obj2.b << endl; Test obj3(10); cout << obj3.a << endl; cout << obj3.b << endl; return 0; }

3、继承控制：final和override

C++11之前，一直没有继承控制关键字，禁用一个类的进一步衍生比较麻烦。 C++ 11添加了两个继承控制关键字：final和override。

用户定义字面量√

参考

模板的改进√

1、右尖括号>改进

在C++98/03的泛型编程中，模板实例化有一个很繁琐的地方，就是连续两个右尖括号(>>)会被编译解释成右移操作符， 【而不是模板参数表的形式】，需要一个空格进行分割，以避免发生编译时的错误。 template <int i> class X{}; template <class T> class Y{}; int main() { Y<X<1> > x1; // ok, 编译成功 Y<X<2>> x2; // err, 编译失败 return 0; }; 在实例化模板时会出现连续两个右尖括号，同样static_cast、dynamic_cast、reinterpret_cast、const_cast表达式转换时 也会遇到相同的情况。C++98标准是让程序员【在>>之间填上一个空格】， 在C++11标准中，要求编译器对模板的右尖括号做单独处理，使编译器能够正确判断出”>>”是一个右移操作符还是模板参数表的结束标记。

2、函数模板的默认模板参数

参考博客

C++11之前，类模板是支持默认的模板参数，却不支持函数模板的默认模板参数：

//1、普通函数带默认参数，c++98 编译通过，c++11 编译通过 void DefParm(int m = 3) {} //2、类模板是支持默认的模板参数，c++98 编译通过，c++11 编译通过 template <typename T = int> class DefClass {}; //3、函数模板的默认模板参数， c++98 - 编译失败，c++11 - 编译通过 template <typename T = int> void DefTempParm() {}

【类模板的默认模板参数必须【从右往左】定义】，函数模板的默认模板参数则没这个限定：

template<class T1, class T2 = int> class DefClass1; template<class T1 = int, class T2> class DefClass2; // 无法通过编译 template<class T, int i = 0> class DefClass3; template<int i = 0, class T> class DefClass4; // 无法通过编译 template<class T1 = int, class T2> void DefFunc1(T1 a, T2 b); template<int i = 0, class T> void DefFunc2(T a);

override√

override确保在派生类中声明的函数跟基类的虚函数有相同的签名：

class A1 { public: //这是第一个虚函数，没有重写，不能用override修饰 virtual int func(int a) { } }; class A2:public A1 { public: //在重写虚函数地方，加上override, 要求重写的虚函数和基类一模一样 virtual int func(int b) override { } }; 上诉代码如果将派生类中的函数改为 virtual int func(float b) override

final√

final阻止类的进一步派生和虚函数的进一步重写：

//final【阻止类】的进一步【派生】，【虚函数】的进一步【重写】 #if 0 class A1 final //加上final，指定A1不能派生 { int a; }; class A2: public A1 //err， 基类不能再派生了 { }; #endif //基类 class B1 { public: virtual void func() final {} //这是最终版本的虚函数，不能再重写 }; //派生类重写基类的虚函数 class B2: public B1 { public: //virtual void func() {} //err, 基类中的虚函数是最终版本，不能再重写 };

decltype√

decltype实际上有点像auto的反函数， auto可以让你声明一个变量， 而decltype则可以从一个变量或表达式中【得到其类型】，如下： #include <typeinfo> #include <iostream> #include <vector> using namespace std; int main() { int i; decltype(i) j = 0; cout << typeid(j).name() << endl; // 打印出"i", g++表示integer float a; double b; decltype(a + b) c; cout << typeid(c).name() << endl; // 打印出"d", g++表示double vector<int> vec; typedef decltype(vec.begin()) vectype; // decltype(vec.begin()) 改名为 vectype vectype k; // 这是auto无法做到的 //decltype(vec.begin()) k; // 这是auto无法做到的 for (k = vec.begin(); k < vec.end(); k++) { // 做一些事情 } enum {Ok, Error, Warning}flag; // 匿名的枚举变量 decltype(flag) tmp = Ok; return 0; }

追踪返回类型

返回类型后置：在函数名和参数列表后面指定返回类型。

基本用法

int getSize(); ​ int main(void) { int tempA = 2; /*1.dclTempA为int.*/ decltype(tempA) dclTempA; /*2.dclTempB为int，对于getSize根本没有定义，但是程序依旧正常，因为decltype只做分析，并不调用getSize().*/ decltype(getSize()) dclTempB; ​ return 0; }

与const结合

double tempA = 3.0; const double ctempA = 5.0; const double ctempB = 6.0； const double *const cptrTempA = &ctempA; /*1.dclTempA推断为const double（保留顶层const，此处与auto不同）*/ decltype(ctempA) dclTempA = 4.1; /*2.dclTempA为const double，不能对其赋值，编译不过*/ dclTempA = 5; /*3.dclTempB推断为const double * const*/ decltype(cptrTempA) dclTempB = &ctempA; /*4.输出为4（32位计算机）和5*/ cout<<sizeof(dclTempB)<<" "<<*dclTempB<<endl; /*5.保留顶层const，不能修改指针指向的对象，编译不过*/ dclTempB = &ctempB; /*6.保留底层const，不能修改指针指向的对象的值，编译不过*/ *dclTempB = 7.0;

与引用结合

int tempA = 0, &refTempA = tempA; ​ /*1.dclTempA为引用，绑定到tempA*/ decltype(refTempA) dclTempA = tempA; /*2.dclTempB为引用，必须绑定到变量，编译不过*/ decltype(refTempA) dclTempB = 0; /*3.dclTempC为引用，必须初始化，编译不过*/ decltype(refTempA) dclTempC; /*4.双层括号表示引用，dclTempD为引用，绑定到tempA*/ decltype((tempA)) dclTempD = tempA; const int ctempA = 1, &crefTempA = ctempA; /*5.dclTempE为常量引用，可以绑定到普通变量tempA*/ decltype(crefTempA) dclTempE = tempA; /*6.dclTempF为常量引用，可以绑定到常量ctempA*/ decltype(crefTempA) dclTempF = ctempA; /*7.dclTempG为常量引用，绑定到一个临时变量*/ decltype(crefTempA) dclTempG = 0; /*8.dclTempH为常量引用，必须初始化，编译不过*/ decltype(crefTempA) dclTempH; /*9.双层括号表示引用,dclTempI为常量引用，可以绑定到普通变量tempA*/ decltype((ctempA)) dclTempI = ctempA;

与指针结合

int tempA = 2; int *ptrTempA = &tempA; /*1.常规使用dclTempA为一个int *的指针*/ decltype(ptrTempA) dclTempA; /*2.需要特别注意，表达式内容为解引用操作，dclTempB为一个引用，引用必须初始化，故编译不过*/ decltype(*ptrTempA) dclTempB;

decltype和auto的区别√

decltype和auto都可以用来推断类型，但是二者有几处明显的差异： 1、auto忽略顶层const，decltype保留顶层const； 2、对引用操作，auto推断出原有类型，decltype推断出引用； 3、对解引用操作，auto推断出原有类型，decltype推断出引用； 4、auto推断时会实际执行，decltype不会执行，只做分析。总之在使用中过程中和const、引用和指针结合时需要特别小心。

Lambdas

参考

C++ 11新特性