详解C++之C++11的牛逼特性

一、列表初始化

1.1 C++98中，标准允许使用花括号{}对数组元素进行统一的列表初始值设定。

1. int array1[] = {1,2,3,4,5};
2. int array2[] = {0};

对对于一些自定义类型，却不行.

1. vector<int> v{1,2,3,4,5};

在C++98中这样无法通过编译，因此需要定义vector之后，在使用循环进行初始赋值。
C++11扩大了用初始化列表的使用范围，让其适用于所有的内置类型和自定义类型，而且使用时，=可以不写

1. // 内置类型
2. int x1 = {10};
3. int x2{10}
4. // 数组
5. int arr1[5] {1,2,3,4,5}
6. int arr2[]{1,2,3,4,5};
7. // 标准容器
8. vector<int> v{1,2,3}
9. map<int,int> m{{1,1},{2,2}}
10. // 自定义类型
11. class Point
12. {
13. int x;
14. int y;
15. }
16. Power p{1,2};

1.2 多个对象的列表初始化
给类(模板类)添加一个带有initializer_list类型参数的构造函数即可支持多个对象的，列表初始化.

1. #include<initializer_list>
2. template<class T>
3. class Vector{
4. public:
5. Vecto(initializer_list<T> l)
6. :_capacity(l.size())
7. ,_size(0){
8. _array = new T[_capacity];
9. for(auto e : l)
10. _array[_size++] = 3;
11. }
12. private;
13. T* _array;
14. size_t _capacity;
15. size_t _size;
16. };

二、变量类型推导

2.1 auto
在C++中，可以使用auto来根据变量初始化表达式类型推导变量的实际类型，简化程序的书写

1. // 不使用auto需要写很长的迭代器的类型
2. map<string,string> m;
3. map<string,string>::iterator it1 = m.begin();
4. // 使用auto就很简单
5. auto it2 = m.begin();

2.1 decltype 类型推导
auto使用时，必须对auto声明的类型进行初始化，否则编译器不能推导出auto的实际类型。
但是有些场景可能需要根据表达式运行后的结果进行类型推导。因为编译时，代码不会运行，auto也就…

1. template<class T1,class T2>
2. T1 Add(const T1& a,const T2& b){
3. return a + b;
4. }

如果用加完后的结果作为函数的返回类型，可能会出错，这就需要程序运行完后才能知道结果的实际类型，即RTTI(运行时类型识别)
decltype可以根据表达式的实际类型推演出定义变量时所用的类型

1. // 推演表达式作为变量的定义类型
2. int a = 1,b=2;
3. decltype(a+b) c;
4. cout<<typeid(c).name()<<endl;
5.  
6. // 推演函数的返回值类型
7. void GetMemory(size_t size){
8. return malloc(size);
9. }
10. cout<<typeid(decltype(GetMemory)).name()<<endl;

三、基于范围for的循环

1. vector<int> v{1,2,3,4,5};
2. for(const auto& e : v)
3. cout<<e<<' ';
4. cout<<endl;

四、final和override
在我的多态的文章中有介绍：http://www.zzvips.com/article/179974.html

五、委派构造函数
委派构造函数可以通过委派其它构造函数，使多构造函数的类编写更加容易

1. class Info
2. {
3. public;
4. Info()
5. :_type(0)
6. ,_name('s')
7. {}
8. Info(int type)
9. :_type(type)
10. ,_name('a')
11. {}
12. Info(char a)
13. :_type(0)
14. ,_name(a)
15. {}
16. pirvate;
17. int _type;
18. char _name;
19. };

上面的构造函数除了初始化列表不同之外，其它部分都是类似的，代码重复，可以使用委派构造函数
委派构造函数就是把构造的任务委派给目标构造函数来完成类的构造

1. class Info
2. {
3. // 目标构造函数
4. public:
5. Info()
6. :_type(0)
7. ,_a('a')
8. {}
9. // 委派构造函数
10. Info(int type)
11. :Info()
12. {
13. _type = type;
14. }
15. private;
16. int _type = 0;
17. char _a = 'a';
18. };

在初始化列表中调用“基准版本”的构造函数称为委派构造函数，而被调用的“基准版本”则称为目标构造函数

六、默认函数控制
在C++中对于空类，编译器会生成一些默认的成员函数，如果在类中显式定义了，编译器就不会重新生成默认版本。但是如果在一个类中声明了带参的构造函数，如果又需要定义不带参的实例化无参的对象。这时候编译器是有时生成，有时不生成，就会造成混乱，C++11可以让程序员自己控制是否需要编译器生成。

6.1 显式缺省函数
在C++11中，可以在默认函数定义或声明时加上=default，来让编译器生成该函数的默认版本。

1. class A
2. {
3. public:
4. A(int a)
5. :_a(a)
6. {}
7. A() = default; // 显式缺省构造函数
8. A& operator=(const A& a); // 在类中声明，在类外定义时，让编译器生成默认赋值运算符重载
9. private:
10. int _a;
11. };
12. A& A::operator=(const A& a) = default;

6.2 删除默认函数
要想限制一些默认函数的生成，在C++98中，可以把该函数设为私有，不定义，这样，如果有人调用就会报错。在C++11中，可以给该函数声明加上=delete就可以。

1. class A
2. {
3. A(int a)
4. :_a(a)
5. {}
6. A(constA&) = delete; // 禁止编译器生成默认的拷贝构造函数
7. private:
8. int _a;
9. };

七、右值引用
7.1 移动语义

1. class String
2. {
3. public:
4. String(char* str = '")
5. {
6. if(str == nullptr)
7. _str = "";
8. _str = new char[strlen(str)+1];
9. strcpy(_str,str);
10. }
11. String(const String& s)
12. :_str(new char[strlen(c._str)+1])
13. {
14. strcpy(_str,s._str);
15. }
16. ~String()
17. {
18. if(_str)
19. delete[] _str;
20. }
21. private:
22. char* _str;
23. };
24.  
25. String GetString(char* pStr)
26. {
27. String strTemp(pStr);
28. return strTemp;
29. }
30.  
31. int main()
32. {
33. String s1("hello");
34. String s2(GetString("world"));
35. return 0;
36. }

在上面的代码中，GetString函数返回的临时对象，将s2拷贝成功之后，立马销毁了(临时对象
的空间被释放)；而s2拷贝构造的时，又需要分配空间，一个刚释放，一个又申请，有点多此一举，那能否把GetString返回的临时对象的空间直接交给s2呢？这样s2也不需要重新开辟空间了。

移动语义：将一个对象资源移动到另一个对象中的方式,在C++中要实现移动语义，必须使用右值引用.

7.2 C++中的右值
右值引用，顾名思义就是对右值的引用。在C++中右值由纯右值和将亡值构成。

• 纯右值：用于识别变量和一些不跟对象关联的值。比如：常量、运算符表达式等、
• 将亡值：声明周期将要结束的对象。比如：在值返回时的临时对象

7.3 右值引用
格式：类型&& 应用变量名字 = 实体；
使用场景：
1、与移动语义相结合，减少必须要的资源的开辟，提高运行效率

1. String&& GetString(char* pStr)
2. {
3. String strTemp(pStr);
4. return strTemp;
5. }
6.  
7. int main()
8. {
9. String s1("hello");
10. String s2(GetString("world"));
11. return 0;
12. }

2、给一个匿名对象取别名，延长匿名对象的生命周期

1. String GetString(char* pStr) {
2. return String(pStr);
3. }
4. int main()
5. {
6. String&& s = GetString("hello");
7. return 0; }

注意：

• 右值引用在定义时必须初始化
• 右值引用不能引用左值

1. int a = 10;
2. int&& a1; // 未初始化，编译失败
3. int&& a2 = a; // 编译失败，a是一个左值
4. // 左值是可以改变的值

7.4 std::move()
C++11中，std::move()函数位于头文件中，它可以把一个左值强制转化为右值引用，通过右值引用使用该值，实现移动语义。该转化不会对左值产生影响.
注意：其更多用在生命周期即将结束的对象上。

7.5 移动语义中要注意的问题
1、在C++11中，无参构造函数/拷贝构造函数/移动构造函数实际上有三个版本

1. Object()
2. Object(const T&)
3. Object(T&&)

2、如果将移动构造函数声明为常右值引用或者返回右值的函数声明为常量，都会导致移动语义无法实现

1. String(const String&&);
2. const String GetString();

3、C++11默认成员函数，默认情况下，编译器会隐士生成一个移动构造函数，是按照位拷贝来进行。因此在涉及到资源管理时，最好自己定义移动构造函数。

1. class String
2. {
3. public:
4. String(char* str = "")
5. {
6. if(str == nullptr)
7. str = "";
8. _str = new char[strlen(str)+1];
9. strcpy(_str,str);
10. }
11. // 拷贝构造
12. // String s(左值对象)
13. String(const String& s)
14. :_str(new char[strlen(s._str) + 1])
15. {
16. strcpy(_str,s_str);
17. }
18. // 移动构造
19. // String s(将亡值对象)
20. String(String&& s)
21. :_str(nullptr)
22. {
23. swap(_str,s._str);
24. }
25. // 赋值
26. String& operator=(const String& s)
27. {
28. if(this != &s)
29. {
30. char* tmp = new char[strlen(s._str)+1];
31. stcpy(tmp,s._str);
32. delete[] _str;
33. _str = tmp;
34. }
35. return *this;
36. }
37. // 移动赋值
38. String& operator=(String&& s)
39. {
40. swap(_str,s._str);
41. return *this;
42. }
43. ~String()
44. {
45. if(_str)
46. delete[] _str;
47. }
48. // s1 += s2 体现左值引用，传参和传值的位置减少拷贝
49. String& operator+=(const String& s)
50. {
51. // this->Append(s.c_str());
52. return *thisl
53. }
54. // s1 + s2
55. String operator+(const String& s)
56. {
57. String tmp(*this);
58. // tmp.Append(s.c_str());
59. return tmp;
60. }
61. const char* c_str()
62. {
63. return _str;
64. }
65. private:
66. char* _str;
67. };
68. int main()
69. {
70. String s1("hello"); // 实例化s1时会调用移动构造
71. String s2("world");
72. String ret
73. ret = s1 + s2 // +返回的是临时对象，这里会调用移动构造和移动赋值，减少拷贝
74.  
75. vector<String> v;
76. String str("world");
77. v.push_back(str); // 这里调用拷贝构造函数
78. v.push_back(move(str)); // 这里调用移动构造，减少一次拷贝
79. return 0;
80. }

总结：
左值：可以改变的值；
右值: 不可以改变的值(常量，表达式返回值，临时对象)
左值引用： int& aa = a; 在传参和传值的位置使用，减少拷贝，提高效率
右值引用： int&& bb = 10; 在传值返回和将亡值传参时，通过调用移动构造和移动赋值，减少拷贝，提高效率。
const 左值引用可以引用右值
右值引用可以应用move后的左值

7.6 完美转发
完美转发是指在函数模板中，完全按照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数

1. void Func(int x)
2. {
3. // ......
4. }
5. template<typename T>
6. void PerfectForward(T t)
7. {
8. Fun(t);
9. }

PerfectForward为完美转发的模板函数，Func为实际目标函数，但上面的转发还不够完美，完美转发是目标函数希望将参数按照传递给转发函数的实际类型转给目标函数，而不产生额外开销,就好像没有转发者一样.
所谓完美：函数模板在向其他函数传递自身形参时，如果相应实参是左值，就转发左值；如果是右值，就转发右值。(这样是为了保留在其他函数针对转发而来的参数的左右值属性进行不同处理，比如参数为左值时实施拷贝语义、参数为右值时实施移动语义)
在C++11中，通过forward函数来实现完美转发。

1. void Fun(int &x){cout << "lvalue ref" << endl;}
2. void Fun(int &&x){cout << "rvalue ref" << endl;}
3. void Fun(const int &x){cout << "const lvalue ref" << endl;}
4. void Fun(const int &&x){cout << "const rvalue ref" << endl;}
5. template<typename T>
6. void PerfectForward(T &&t){Fun(std::forward<T>(t));}
7. int main()
8. {
9. PerfectForward(10); // rvalue ref
10. int a;
11. PerfectForward(a); // lvalue ref
12. PerfectForward(std::move(a)); // rvalue ref
13. const int b = 8;
14. PerfectForward(b); // const lvalue ref
15. PerfectForward(std::move(b)); // const rvalue ref
16. return 0; }

八、lambda表达式
在C++98中，如果想对一个数据集合中的元素进行排序，可以使用std::sort()方法，但其默认按照小于比较，如果想排降序，则要传入第三个参数，可以使用std::greater()的比较方法，

1. vector<int> v{1,4,3,2,7,6,5};
2. // 默认按照小于比较，结果是升序
3. sort(v.begin(),v.end());
4. // 传入第三个模板参数std::greater<T>(),按照大于比较，默认是降序
5. sort(v.begin(), v.end(),greater<int>());

但是该方法只支持内置类型，对于用于自定义的类型就无能为力了，这是就需要用于自定义排序时的规则。目前我们可以通过函数指针，仿函数，lambda来解决。

1、lambda 表达式语法

[捕捉列表](参数列表)mutable->返回值类型{函数体}
捕捉列表：该列表出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表可以捕捉上下文中的变量供lambda函数使用
参数列表：与普通函数的参数列表一致。则可以连同()一起省略
mutable:默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符，参数列表不可以省略(即使参数列表为空)
->返回值类型。用于追踪返回值类型。没有返回值时可以省略。返回值类型明确的情况下，也可以省略
{函数体}：在该函数体，除了可以使用参数外，也可以使用捕捉到的所有变量

!!!在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。

1. int main()
2. {
3. // 最简单的lambda表达式
4. []{};
5. // 省略参数列表和返回值类型,返回值类型有编译器推演为int
6. int a=3,b=4;
7. [=]{return a+3;};
8. // 省略返回值类型
9. auto fun1 = [&](int c){b = a + c;};
10. // 各部分完整的lambda函数
11. auto fun2 = [=,&b](int c)->int(return += a + c;);
12. // 复制捕捉x
13. int x = 10;
14. auto add_x = [x](int a)mutable{x *= 2; return a + x;};
15. return 0;
16. }

2、捕获列表说明
捕获列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是引用

1. a [var]:表示值传递方式捕获变量var
2. b [=]:表示值传递方式捕获所有父作用域中的变量(包括this)
3. c [&var]:表示引用传递变量var
4. d [&]:表示引用传递捕获所有父作用域中的变量(this)
5. e [this]：表示值传递方式捕获当前的this指针

!!!：

1. a 父作用域包含lambda函数的语句块
2. b 语法上捕获列表可由多个捕获项组成，并以逗号分隔
3. 比如：[=,&a,&b]：以引用传递的方式捕获变量a 和 b，值传递的方式捕获其它所有变量.
4. [&,a,this]；值传递的方式捕获变量a和this，引用方式捕获其它变量。
5. 捕捉列表不允许变量重复传递，否则会导致编译错误。比如：[=,a]以传值的方式捕获了所有变量，又重复捕捉a
6. c 块作用域以外的lambda函数捕捉列表必须为空
7. e 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错
8. f lambda表达式之间不能相互赋值，即使看起来类型相同.

1. void (*PF)();
2. int main()
3. {
4. auto f1 = []{cout<<"hello world"<<endl;};
5. auto f2 = []{cout<<"hello world"<<endl;};
6. f1= f2; // 这里会编译失败，提示找不到operator=()
7. auto f3(f2); // 允许使用一个lambda表达式拷贝一个新的福分
8. PF = f2; // 可以将lambda表达式赋值给相同类型的指针
9. return 0;
10. }

3、lambda表达式与函数指针、仿函数

1. typedef bool (*GTF) (int, int);
2. bool greater_func1(int l, int r)
3. {
4. return l > r;
5. }
6.  
7. struct greater_func2
8. {
9. bool operator()(int l, int r)
10. {
11. return l > r;
12. }
13. };
14.  
15. int main()
16. {
17. // 函数指针
18. GTF f1 = greater_func1; // typedef 定义
19. // bool (*f1) (int, int) = greater_func1; // 不typedef ,直接原生写法，可读性差
20. cout<< f1(1,2)<<endl;
21. // 仿函数
22. greater_func2 f2;
23. cout<< f2(1,2)<<endl;
24. // lamba表达式
25. auto f3 = [] (int l, int r) ->bool{return l > r;};
26. cout<< f3(1,2)<<endl;
27.  
28. int a[] = {1,2,4,5,3,7,6,9,8};
29. sort(a,a+sizeof(a)/sizeof(a[0]),f1);
30. sort(a,a+sizeof(a)/sizeof(a[0]),f2);
31. sort(a,a+sizeof(a)/sizeof(a[0]),f3);
32. // sort函数第三个模板参数能接受函数指针，仿函数、lambda表达式，是因为其第三个参数是一个模板custom (2)
33. template <class RandomAccessIterator, class Compare>
34. void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
35.  
36. return 0;
37. }

函数指针，仿函数，lambda用法上是一样的，但函数指针类型定义很难理解，仿函数需要实现运算符的重载，必须先定义一个类，而且一个类只能实现一个()operator的重载。(ep:对商品的不同属性实现比较就需要实现不同的类)，要先定义好才能使用。而lambda可以定义好直接使用.

1. struct Goods
2. {
3. string _name;
4. double _price;
5. double _appraise;
6. };
7.  
8. int main()
9. {
10. Goods gds[] = { { "苹果", 2.1, 10 }, { "相交", 3, 8 }, { "橙子", 2.2, 7 }, { "菠萝", 1.5, 10 } };
11.  
12. sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& g1, const Goods& g2)->bool
13. {return g1._price > g2._price; });
14.  
15. sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& g1, const Goods& g2)->bool
16. {return g1._appraise > g2._appraise; });
17.  
18. return 0;
19. }

上面的例子就体现了其现做现用的特性。

4、lambda表达式的底层

1. class Rate
2. {
3. public:
4. Rate(double rate)
5. : _rate(rate)
6. {}
7. double operator()(double money, int year)
8. {
9. return money * _rate * year;
10. }
11. private:
12. double _rate;
13. };
14. int main()
15. {
16. // 函数对象
17. double rate = 0.49;
18. Rate r1(rate);
19. r1(10000, 2);
20. // 仿函数
21. auto r2 = [=](double monty, int year)->double{return monty*rate*year; };
22. r2(10000, 2);
23. return 0; }

函数对象将rate作为其成员变量，在定义对象时候给出初始值即可，lambda表达式通过捕获列表直接捕获该变量.

通过上面的图可以看出，实际在底层编译器对于处理lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator();
并且编译器是通过lambda_+uuid来唯一辨识一个lambda表达式的
九、线程库
C++11中引入了线程库，使得在C++在并行编程时可以不需要依赖第三方库，而且在原子操作中引入了原子类的概念。
要使用标准库中的线程，必须包含头文件

1. #include<iostream>
2. #include<thread>
3.  
4. void fun()
5. {
6. std::cout << "A new thread!" << std::endl;
7. }
8. int main()
9. {
10. std::thread t(fun);
11. t.join();
12. std::cout << "Main thread!" << std::endl;
13. system("pause");
14. return 0;
15. }

9.1 线程的启动
C++线程库通过构造一个线程对象来启动一个线程，该线程对象中包含了线程运行时的上下文环境，如：线程函数、线程栈、线程其实状态、以及线程ID等，把所有操作全部封装在一起，在同一传递给_beginthreadex()创建线程函数来实现(_beginthreadex是windows中创建线程的底层c函数)
std::thread()创建一个新的线程可以接受任意的可调用对象类型,包括lambda表达式，函数，函数对象，函数指针

1. // 使用lambda表达式作为线程函数创建线程
2. int main()
3. {
4. int n1 = 1;
5. int n2 = 2;
6. std::thread t([&](int addNum){n1 += addNum; n2 += addNum; }, 3);
7. t.join();
8. std::cout << n1 << " " << n2 << std:: endl;
9. system("pause");
10. return 0;
11. }

9.1 线程的结束
启动一个线程后，当线程执行完毕时，如果护手线程使用的资源，thread库提供了两种选择。
1、join()
join():会主动等待线程终止，在调用进程中join(),当新的线程终止时，join()会清理相关的资源，然后返回，调用线程在继续向下执行。由于join()清理了线程的相关资源，thread对象与已销毁的线程就没有关系了，因此一个线程对象每次只能join()一次，如果多次调用join(),joinable()会返回false;

1. int main()
2. {
3. int n1 = 1;
4. int n2 = 2;
5. std::thread t([&](int addNum){n1 += addNum; n2 += addNum; }, 3);
6. std::cout << "join before,joinable=" << t.joinable() << std::endl;
7. t.join();
8. std::cout << "join after,joinable=" << t.joinable() << std::endl;
9. system("pause");
10. return 0;
11. }
12. // 执行结果：
13. join before,joinable=1
14. join after,joinable=0

2、detach()
detach：会从调用线程中分离出新的线程，之后不能再与新线程交互。这是调用joinable()会返回false。分离的线程会在后台运行，其所有权和控制权会交给C++运行库。C++运行库会保证在线程退出时，其相关资源能正确回收。

1. int main()
2. {
3. int n1 = 1;
4. int n2 = 2;
5. std::thread t([&](int addNum){n1 += addNum; n2 += addNum; }, 3);
6. std::cout << "join before,joinable=" << t.joinable() << std::endl;
7. t.detach();
8. std::cout << "join after,joinable=" << t.joinable() << std::endl;
9. system("pause");
10. return 0;
11. }

注意，必须在thread对象销毁之前作出选择，因为线程在join()或detach()之前，就可能已经结束，如果之后在分离，线程可能会在thread对象销毁之后继续运行。

9.3 原子性操作库
多线程最主要的问题是共享数据带来的问题(线程安全)。如果数据都是只读的，没有问题，因为只读不会影响数据，不会涉及数据的修改，所有线程都会获得同样的数据。但是，当多个线程要修改数据时，就会产生很多潜在的麻烦。

1. int sum = 0;
2.  
3. void fun(size_t num)
4. {
5. for (size_t i = 0; i < num; i++)
6. sum++;
7. }
8.  
9. int main()
10. {
11. std::cout << "before,sum=" << sum << std::endl;
12. std::thread t1(fun, 100000000);
13. std::thread t2(fun, 100000000);
14. t1.join();
15. t2.join();
16. std::cout << "After,sum=" << sum << std::endl;
17. system("pause");
18. return 0;
19. }

当fun的参数比较大时，就会产生和预期不相符的结果.
在C++98中可以通过加锁来保护共享数据。

1. int sum = 0;
2. std::mutex m;
3.  
4. void fun(size_t num)
5. {
6. for (size_t i = 0; i < num; i++)
7. {
8. m.lock();
9. sum++;
10. m.unlock();
11. }
12. }

虽然加锁结果了这个问题：但是它有一个缺陷:只要有一个线程在对sum++的时候，其它线程就会阻塞，会影响程序运行的效率，而且锁如果控制不好，或导致思索的问题。
因此在C++11中引入了原子操作。对应于内置的数据类型，原子数据类型都有一份对应的类型。

要使用以上的原子操作，需要添加头文件

1. #include<thread>
2. #include<mutex>
3. #include<atomic>
4.  
5. std::atomic_int sum{ 0 };
6.  
7. void fun(size_t num)
8. {
9. for (size_t i = 0; i < num; i++)
10. {
11. sum ++; // 原子的
12. }
13. }
14.  
15. int main()
16. {
17. std::cout << "before,sum=" << sum << std::endl;
18. std::thread t1(fun, 10000000);
19. std::thread t2(fun, 10000000);
20. t1.join();
21. t2.join();
22. std::cout << "After,sum=" << sum << std::endl;
23. system("pause");
24. return 0;
25. }

到此这篇关于详解C++之C++11的牛逼特性的文章就介绍到这了,更多相关C++11特性内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/aixintianshideshouhu/article/details/94548940