C++ 11

川长思鸟来 2022-07-11 17:24 142阅读 0赞

# 转载：http://blog.csdn.net/feng\_ma\_niu/article/details/40002291 #

# 1 引子 #

去年年底，开始学习[C++][C]11新标准，也曾经发表过一篇关于C++11新增内容的帖子，由于CSDN很纠结的编辑页面，最终这篇帖子烂尾了，实在是汗颜。

最近，在公司分享了关于C++11的部分内容，借此机会，对于平时常用的，以及在Visual Studio 2012中支持的一些功能进行了总结，也趁此发表这篇帖子，算是对上次烂尾的一个补足吧。

# 2 C++发展史 #

说到C++ 11新标准，必然应该先了解一下C++的整个发展历程。

![SouthEast][]

1979年，C++之父Bjarne Stroustrup开始扩展原有[C语言][C 1]的功能，使其支持面向对象的一些新特性。

1983年，C++正式出现，原来的名字为C with Classes，同时加入了很多新特性，例如虚函数等。

1985年，C++的经典巨作《The C++ Programming Language》（简称TCPL）第一版发布，如今已于2013年5月更新到第四版了。

1998年，C++标准委员会发布了第一个版本的C++标准，即我们常说的C++98。

2003年，第二个版本的标准发布，主要是修正C++98中出现的一些缺陷。

2005年，发布了技术报告Library Technical Report 1，简称TR1，提供了很多有望成为下一个版本标准的C++特性。

2011年，经过了10多年的时间，C++标准委员会终于发布了第三个版本的C++标准。

2014年，发布了第四个版本标准，主要是对C++11缺陷的修正和部分功能的添加。

# 3 C++11新增功能(部分)和VS12支持状况 #

此处只列举了部分功能以及VisualStudio 2012对其的支持，其他更多的功能请参考C++ 11的标准文档。

<table style="color:rgb(54,46,43); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
 <tr> 
 <td style="background:rgb(225,244,255)"> C++ 11新增功能 </td> 
 <td style="background:rgb(225,244,255)"> VS12是否支持 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 右值引用 </td> 
 <td style="background:rgb(244,251,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(249,253,255)"> 引用限定符 </td> 
 <td style="background:rgb(249,253,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 非静态成员初始值 </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(249,253,255)"> 可变参数模板 </td> 
 <td style="background:rgb(249,253,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 初始化列表 </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(249,253,255)"> static_assert </td> 
 <td style="background:rgb(249,253,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 自动推导 </td> 
 <td style="background:rgb(244,251,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(249,253,255)"> 追踪返回类型 </td> 
 <td style="background:rgb(249,253,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> Lambda </td> 
 <td style="background:rgb(244,251,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(249,253,255)"> nullptr </td> 
 <td style="background:rgb(249,253,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 强类型enum </td> 
 <td style="background:rgb(244,251,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(249,253,255)"> constexpr </td> 
 <td style="background:rgb(249,253,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 委托构造 </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 继承构造函数 </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 枚举前置声明 </td> 
 <td style="background:rgb(244,251,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> Unicode支持 </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> override和final </td> 
 <td style="background:rgb(244,251,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> noexpect </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 基于范围的for </td> 
 <td style="background:rgb(244,251,255)"> 是 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 原生字符串 </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> default和delete </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 内联命名空间 </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 对齐 </td> 
 <td style="background:rgb(244,251,255)"> 部分支持 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> 多线程 </td> 
 <td style="background:rgb(244,251,255)"> 否 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> __func__ </td> 
 <td style="background:rgb(244,251,255)"> 部分支持 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(244,251,255)"> long long </td> 
 <td style="background:rgb(244,251,255)"> 支持 </td> 
 </tr> 
 </tbody> 
</table>

# 4 功能详解 #

## 4.1 Lambda表达式 ##

Lambda表达式是C++ 11标准中非常实用的一个功能，也是非常重要的一个功能，应该是每个人都应该熟练掌握的。

### 4.1.1 基本声明 ###

Lambda表达式是一个匿名函数，即只有函数体，没有名字的函数。C++ 11中Lambda表达式的基本语法为：

\[capture list\] (parameterlist) mutable \->return type \{ function body \}

Lambda表达式的使用要注意几点。第一，非黑色部分标注的为可省略的部分，即一个最简单的表达式可以为：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **void** S1\_SimpleLambda()  
2. \{  
3.     auto simpleLambda = \[\]\{std::cout << "SimpleLambda" << std::endl;\};  
4.     **return** simpleLambda();  
5. \}

第二，一个Lambda表达式默认是const类型的，即不能改变父作用域内任意变量的值。如果想要改变，则需要增加mutable声明，添加mutable声明后，参数列表不可省略。例如：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **void** ValueCaptureTest2()  
2. \{  
3.     **int** intValue = 0;  
4.     auto test2 = \[=\]() **mutable** \{std::cout << "Lambda: " << ++intValue << std::endl;\};  
5.     test2();  
6.     std::cout << "Out Lambda: " << intValue << std::endl;  
7. \}

第三，Lambda表达式默认是一个内联的函数，编译器会对其调用进行优化，所以一个Lambda表达式应该短小精悍。

### 4.1.2 捕获列表 ###

Lambda表达式的捕获列表（Capture List）主要有以下几种：

Ø  \[var\]   表示值传递方式捕捉变量var。

Ø  \[=\]       表示值传递方式捕捉所有父作用域的变量（包括this）。

Ø  \[&var\]         表示引用传递方式捕捉变量var。

Ø  \[&\]      表示引用传递方式捕捉父作用域的变量（包括this）。

Ø  \[this\]  表示值传递方式捕捉当前的this指针。

捕获列表是一个很容易出错的地方，所以应该加强注意。下面是几个简单的示例。第一，使用值传递方式进行捕获：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **class** FMNValueCapture  
2. \{  
3. **public**:  
4.     FMNValueCapture() : m\_intValue(0) \{\}  
5.    
6.    
7.     **void** ValueCaptureTest1()  
8.     \{  
9.         auto test1 = \[=\]\{std::cout << "Lambda: " << ++m\_intValue << std::endl;\};  
10.         test1();  
11.         std::cout << "Out Lambda: " << m\_intValue << std::endl;  
12.     \}  
13.    
14.    
15.     **void** ValueCaptureTest2()  
16.     \{  
17.         **int** intValue = 0;  
18.         auto test2 = \[=\]() **mutable** \{std::cout << "Lambda: " << ++intValue << std::endl;\};  
19.         test2();  
20.         std::cout << "Out Lambda: " << intValue << std::endl;  
21.     \}  
22.    
23.    
24. **private**:  
25.     **int** m\_intValue;  
26. \};

第二，使用引用传递方式进行捕获：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **void** S3\_ReferenceCapture()  
2. \{  
3.     **int** intValue = 0;  
4.     auto refCap = \[&intValue\]\{std::cout << "Lambda: " << ++intValue << std::endl;\};  
5.     refCap();  
6.     std::cout << "Out Lambda: " << intValue << std::endl;  
7. \}

上面仅列举了几个例子，具体还要大家亲自进行尝试才能融会贯通。

### 4.1.3 Lambda与STL ###

Lambda表达式与STL中各种容器和[算法][Link 1]组合使用，才是威力最为强大的所在。下面列举一个例子，大家可以参考一下，例子为遍历map，并对map的值进行处理（示例分别对其加1并输出）：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **typedef** std::map<**int**, **int**> FMNIntMap;  
2.    
3.    
4. **void** S4\_StlExample()  
5. \{  
6.     FMNIntMap intMap;  
7.     **for** (**int** i = 0; i < 5; ++i)  
8.     \{  
9.         intMap.insert(std::make\_pair(i, i));  
10.     \}  
11.    
12.     std::cout << "first time." << std::endl;  
13.     std::transform(intMap.begin(), intMap.end(),   
14.         std::ostream\_iterator<std::string>(std::cout, "\\n"),   
15.         \[\](FMNIntMap::value\_type& val)->std::string  
16.     \{  
17.         std::stringstream ss;  
18.         ss << "first: " << val.first << ", second: " << val.second;  
19.         **return** ss.str();  
20.     \});  
21.    
22.     std::cout << "second time." << std::endl;  
23.     std::for\_each(intMap.begin(), intMap.end(), \[\](std::pair<**const** **int**, **int**>& val)  
24.     \{  
25.         ++val.second;  
26.     \});  
27.     std::transform(intMap.begin(), intMap.end(),   
28.         std::ostream\_iterator<std::string>(std::cout, "\\n"),   
29.         \[\](FMNIntMap::value\_type& val)->std::string  
30.     \{  
31.         std::stringstream ss;  
32.         ss << "first: " << val.first << ", second: " << val.second;  
33.         **return** ss.str();  
34.     \});  
35. \}

### 4.1.4 Lambda与仿函数 ###

通过上面的例子，大家可以发现，Lambda表达式和仿函数的用法非常相似。但是与仿函数还是有所区别。

第一，Lambda表达式默认为内联函数，而仿函数不是。

第二，仿函数可以具有状态（即成员），通过状态来分别执行不同的分支，但是Lambda不可以。

第三，仿函数可以跨作用域，而Lambda不可以，例如下面这段代码是错误的：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **static** **int** g\_intVal = 1;  
2.    
3.    
4. **void** S5\_OutScope()  
5. \{  
6.     auto outScope = \[g\_intVal\]\{std::cout << "Lambda: " << ++g\_intVal << std::endl;\};  
7.     outScope();  
8. \}

## 4.2 类型推导与返回值类型追踪 ##

C++ 11中增加了强大的类型推导功能，使得开发效率得以提升，并且大幅度简化简洁了代码。

### 4.2.1 类型推导 ###

类型推导主要有两个，auto和decltype，通过一个简单的例子，就可以明白它们的具体功能。

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **void** S6\_AutoDecltype()  
2. \{  
3.     std::vector<**int**> intVec;  
4.     std::vector<**int**>::iterator intVecIter1 = intVec.begin();  
5.     auto intVecIter2 = intVec.begin();  
6.     decltype(intVec.begin()) intVecIter3 = intVec.begin();  
7. \}

这样，就可以不必定义复杂的迭代器，也不必担心各种计算类型。但是需要注意的是，要区分推导类型是引用传递还是值传递。

### 4.2.2 返回值追踪 ###

既然有了类型推导，想必大家会想如果返回值也是自动推导，岂不不用担心各种复杂的逻辑了？例如下面的代码：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **template** <**class** T1, **class** T2>  
2. decltype(t1 + t2) Sum(T1& t1, T2& t2)  
3. \{  
4.     **return** (t1 + t2);  
5. \}

这样，就可以任意类型，只要支持加法运算，就可以进行加和了，例如int和double值进行加和等。但是编译器推导(t1 + t2)时，由于是从左向右解析，故此时尚未知t1和t2的类型，所以推导失败。

为了解决这个问题，C++11提出了返回值追踪的功能。

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **template** <**class** T1, **class** T2>  
2. auto Sum(T1& t1, T2& t2) -> decltype(t1 + t2)  
3. \{  
4.     **return** (t1 + t2);  
5. \}

## 4.3 基于范围的for循环 ##

这个比较简单，直接参考示例代码：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **void** S11\_ForRange()  
2. \{  
3.     std::vector<**int**> intVec;  
4.     intVec.push\_back(1);  
5.     intVec.push\_back(3);  
6.     intVec.push\_back(5);  
7.     intVec.push\_back(7);  
8.    
9.     **for** (auto i : intVec)  
10.     \{  
11.         std::cout << i << std::endl;  
12.     \}  
13.    
14.     **int** intArray\[\] = \{2, 4, 6, 8\};  
15.     **for** (auto i : intArray)  
16.     \{  
17.         std::cout << i << std::endl;  
18.     \}  
19. \}

## 4.4 空指针nullptr ##

对于常用的NULL来说，其本质上是具有二义性的，例如：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **void** NullFunc(**int** val)  
2. \{  
3.     std::cout << "null is int." << std::endl;  
4. \}  
5.    
6.    
7. **void** NullFunc(**void**\* pVal)  
8. \{  
9.     std::cout << "null is a pointer" << std::endl;  
10. \}  
11.    
12.    
13. **void** S9\_Nullptr()  
14. \{  
15.     static\_assert(NULL == nullptr, "Error: nullptr is not NULL");  
16.    
17.     NullFunc(NULL);  
18. \}

NULL本质上为指针，但是定义却为0，即该函数会将NULL做为一个int值处理，产生了二义性。所以对于这个场景，C++ 11提出了nullptr，我们的代码中应该尽量用nullptr来标识一个空指针。

## 4.5 强类型enum和前置声明 ##

首先说enum的前置声明，这个与struct和class的前置声明类似，例子如下：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **enum** **class** EnumClass : **char**;  
2.     
3.     
4.  **class** RCEnumPreDef  
5.  \{  
6.  **private**:  
7.      EnumClass m\_type;  
8.  \};  
9.     
10.    
11. **enum** **class** EnumClass : **char**  
12. \{  
13.     TYPE\_A,  
14.     TYPE\_B,  
15.     TYPE\_C,  
16.     TYPE\_D = 30000,  
17. \};

其次，可以将enum定义为class类型，这样使用时候必须加作用域限制，提高了安全性。并且可以指定enum的范围，当超过范围时，作为溢出处理。

但是声明为强类型后，不能使用int或者char等进行enum的遍历比较操作，这个应在使用时进行权衡。

## 4.6 override与final ##

override和final主要用来对基类virtual函数的覆盖做声明。

override即声明该函数是对基类函数的覆盖，当参数不同或者返回值不同或者基类函数不为虚函数时，编译器会提示error。

final则是对某一函数的覆盖做终止。即子类不能再对此函数覆盖，如果覆盖，编译器会提示error。

通过override和final，可以提高代码的安全性，明确接口，终止接口覆盖等好处。

示例代码如下：

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **class** FMNBase  
2. \{  
3. **public**:  
4.     FMNBase() \{\}  
5.    
6.     **virtual** ~FMNBase() \{\}  
7.    
8.     **virtual** **void** Func(**int**) \{std::cout << "Base" << std::endl;\}  
9. \};  
10.    
11.    
12. **class** FMNChildA : **public** FMNBase  
13. \{  
14. **public**:  
15.     **void** Func(**int**) override \{std::cout << "A Override" << std::endl;\}  
16. \};  
17.    
18.    
19. **class** FMNChildB : **public** FMNChildA  
20. \{  
21. **public**:  
22.     **void** Func(**int**) final \{std::cout << "B Override" << std::endl;\}  
23. \};  
24.    
25.    
26. **class** FMNChildC : **public** FMNChildB  
27. \{  
28. **public**:  
29.     // Error  
30.     **void** Func(**int**) override \{std::cout << "C Override" << std::endl;\}  
31. \};  
32.    
33.    
34. **class** FMNChildD : **public** FMNChildA  
35. \{  
36. **public**:  
37.     // Error  
38.     **void** Func() override \{std::cout << "D Override" << std::endl;\}  
39. \};

## 4.7 右值引用 ##

为了定义“右值引用”的概念，首先说明左值，右值的含义，加深对此的理解。

左值，是指可以放在赋值符号“=”的左边，但其实也表示能作为&和++等操作符的操作数。可以取其地址和名字。

右值，指的是引用了一个存储在某个内存地址里的数据。不能取其地址，且没有名字。又分为“将亡值”和“纯右值”两种。纯右值即C++98标准中的右值，例如一些字面量等。将亡值即C++11标准中的右值引用。

通过右值引用，可以大幅度提高代码的效率，因为本质上通过内存的转移，可以减少拷贝构造等过程。

下面仅为一个简单的示例，C++ 11实际上提供了对右值引用非常多的支持和定义，所以具体还请参考C++ 11的标准文档。

**\[cpp\]**  [view plain][]   [copy][view plain]

1. **void** ValueFunc(**int**& val)  
2. \{  
3.     std::cout << "Left Value: " << val << std::endl;  
4. \}  
5.    
6.    
7. **void** ValueFunc(**int**&& val)  
8. \{  
9.     std::cout << "Right Value: " << val << std::endl;  
10. \}  
11.    
12.    
13. **void** S8\_RightValue()  
14. \{  
15.     **int** intVal = 0;  
16.     ValueFunc(intVal);  
17.     ValueFunc(1);  
18. \}

## 4.8 其他 ##

除了上述重要的特性外，还有一些较简单的特性，不在详细讨论，例如：

1. static\_assert 编译期的静态断言。

2. STL库新增内容，包括array，forward\_list，unordered\_map，unordered\_set等容器，以及新增的算法。

3. UTF8等编码转换，可以参考头文件<codecvt>。

4. 类型萃取，可以参考头文件<type\_trains>

当然，还有其他很多Visual Studio 2012不支持，或者部分支持的特性，如果使用，还请务必参考微软的官方文档。

# 5 进一步思考 #

人生总是有太多的迷茫与惆怅，有些时候不知道到底该执着下去还是应该放弃。过去，多少个马云在进行拼搏，可是马云终究只有一个。人生总是有两条路要走，第一是选择，第二是坚持。

一个人，如果没有对选择有信心，那他又是凭借着什么坚持呢？转眼间，一年就要过去了，去年写之前那篇文章时的场景还历历在目，如今却茫茫然的“情不知所起，一往而深”的迷茫着。

C++11，许多东西在不知不觉中了然在胸，许多东西看了许多遍却依然有待继续深入。写了这篇文章，又收获了许多许多，真是非常感谢教会我分享的人们！

[C]: http://lib.csdn.net/base/cplusplus
[SouthEast]: /images/20220711/9df27073a3a34a198eb6179c2831b5a6.png
[C 1]: http://lib.csdn.net/base/c
[view plain]: http://blog.csdn.net/feng_ma_niu/article/details/40002291#
[Link 1]: http://lib.csdn.net/base/datastructure