C++11

目录

一、统一的列表初始化
二、声明
三、右值引用和移动语义
四、可变参数模板
五、lamda表达式
六、function包装器和bind

---

一、统一的列表初始化

1.1{}初始化
在C++98中，标准允许使用花括号{}对数组大概结构体元素及进行统一的列表初始化设定
C++11扩大了用大括号扩起的列表(初始化列表)的使用范围，使其可用于所有的内置范例和用户自界说范例使用初始化列表时，可添加等号(=)，也可以不添加
一切都可以用列表初始化

1.         int x = 0;
2.         int y{ 1 };
3.         int z = { 2 };
4.         int a[]{ 1,2,3 };
5.     int a1[5]{ 0 };

复制代码

1. struct add
2. {
3.         add(int x, int y)
4.                 :_x(x)
5.                 ,_y(y)
6.         {
8.         }
9.         int _x;
10.         int _y;
11. };

复制代码

1. add p{ 1,2 };
2. add p1(3, 4);
3. add p2={ 3,4 };
4. const  add& pp2 = { 3,4 };
5. add* p3 = new add[2]{ p,p1 };
6. add* p4 = new add[2]{ {4,5},{6,7} };

复制代码

1. add p1(3, 4);
2. add p2={ 3,4 };

复制代码

这两个可不一样，上面谁人是直接构造，而下面谁人雷同构造实例化出一个对象，再把这个对象拷贝构造给p2，但是连续的构造和拷贝构造就会被编译器直接优化成构造

1. vector<int> v = { 1,2,3,4,5,6 };
2. list<int> l = { 1,2,3,4,5,6 };

复制代码

那这种列表初始化有差别于上面写的谁人，上面谁人是固定的参数数目，这个初始化的数目是磨练改变的，缘故原由就是C++11引入了一个叫initializer_list(可变参数列表)
1.2initializer_list

其实就是开好一段空间，把你列表里面的值存进去，让start指向你的开头，finish指向你的结尾 

1.         auto l1 = { 1,2,3,4,5,6 };
2.         cout << typeid(l1).name() << endl;

复制代码

那initializer_list是怎么去初始化vector大概list的呢，可以一个一个的插入，也可以迭代器区间去初始化
二、声明

C++11提供了多种简化声明的方式，尤其是在使用模板的时候
2.1auto
在C++98中去偷是一个存储范例的阐明符，表明变量是局部存储范例，但是局部域中界说局部的变量默认就是自动存储范例，以是auto就没什么价值了，但是C++11中auto原来的用法，将其用于实现自动范例推断，这样要求必须进行表现初始化，让编译器将界说对象的范例设置为初始化值的范例

1. int main()
2. {
3.         int i = 10;
4.         auto p = &i;
5.         vector<pair<string, string>> dict = { {"apple","苹果"},{"banana","香蕉"} };
6.         auto it = dict.begin();
7.         cout << typeid(p).name() << endl;
8.         cout << typeid(it).name() << endl;
9. }

复制代码

看识别到这么长的范例还是非常实用的 
2.2decltype

typeid只能把范例以字符串的方式打印出来，但是不可以让它作为范例去界说变量

1. int main()
2. {
3.         int i = 1;
4.         double j = 1.1;
5.         cout << typeid(i).name() << endl;
6.         cout << typeid(j).name() << endl;
7.         auto ret = i * j;
8.         vector<decltype(ret)> v;
9.         cout << typeid(v).name() << endl;
10.         return 0;
11. }

复制代码

如果我们需要用ret的范例去实例化vector
decltype可以推导对象的范例。这个范例是可以用来模板实参，大概再界说对象的

2.3 nullptr
由于C++NuLL被界说成字面量0，这样就可能会带来一些标题，因为0既能指针常量，又能表现整型变量，以是处于清楚和安全的角度思量，C++11新增了nullptr，用于表现空指针
2.4范围for循环
这个在前面STL文章已经充分解说了，这里不做太多赘述
2.5智能指针
这个也是一个大模块，以是会针对这个专门写一篇文章
2.6STL的新容器

map和set的哈希表上一篇文章我们已经做了非常细致的解说
array就是静态数组，至于这个东西有什么用呢，大家都知道[]会对越界访问进行检查，就是有了一个更严酷的规范相当于 

1. int main()
2. {
3.         array<int, 10> arr;
4.         arr[10];
5.         return 0;
6. }

复制代码

像这里我们运行一下直接就报错了
但是这个还是很鸡肋的，不如用vector
forward_list就是单链表，只支持头插头删的可以用它
三、右值引用和移动语义

3.1左值引用和右值引用
传统的C++语法中就有引用的语法，而C++11新增了的右值引用语法特性，之前我们了解的引用就叫左值引用。无论是左值引用和右值引用，都是给对象取别名
那什么是左值引用呢
左值是一个表现数据的表达式，我们可以获取它的地址，一样平常可以对它赋值，左值可以出现赋值符号的左边，右值不能出如今赋值符号左边。界说const修饰符后的左值，不能给他赋值，但是可以取它 的地址。左值引用就是给左值的引用，给左值取别名

1. int main()
2. {
3.         int i = 0;
4.         int j = i;
5.         int* p = &i;
6.         int* d = new int(0);
7.         return 0;
8. }

复制代码

能被取地址的就叫左值，左值可以出如今左边也可以出如今右边
什么是右值引用呢
右值也是一个表现数据的表达式，如：表达式返回值，函数返回值等等，右值可以出如今赋值符号的右边，但是不能出如今赋值符号的左边，右值不能取地址，右值引用就是对右值的引用，给右值取别名

1.         10;
2.         i + j;
3.         min(i, j);

复制代码

像这些都是右值，它们都是临时对象

那左值能否给右值取别名呢

1.         int& r = 10;
2.         const int& r1 = 10;

复制代码

直接的是不可的，临时常量是不能被修改的，你转为平常对象是权限的放大以是要加const
右值引用可以给右值取别名

1.         int&& r1 = 10;
2.         int&& r2 = i + j;

复制代码

T&&，这个&&可以看作右值引用符号
右值引用不能给左值取别名，但是右值引用可以给move(左值)取别名

1. int&& r3 = move(i);

复制代码

那么为什么要有左值引用和右值引用呢，引用的本质标题都是淘汰拷贝

1. string& add(string x, string y)
2. {
3.         return x+y;
4. }
5. int main()
6. {
7.         string ret ;
8.         ret = add("1", "2");
9.         return 0;
10. }

复制代码

像这种环境就不可以用左值引用返回，你x+y是临时变量，临时变量出了作用域就烧毁了，自然就不能取别名
但是没有引用以后你x+y要走一个拷贝构造一个临时对象复制一下这个x+y的资源，再把这个临时对象赋值给ret，这期间要用两次深拷贝
有人说用右值引用可不可以，右值引用改变不了这个对象的生命周期，改变不了它出了作用域就烧毁的事实，这就有了移动构造和移动赋值
3.2移动构造和移动赋值
C++把右值分为纯右值和将亡值
纯右值 内置范例右值
将亡值 自界说的右值

这个成本是很大的 

我们移动构造就是实现一个右值引用的构造，构造一个临时对象指向和你x+y一样的资源，然后我们同样的实现一个右值引用的赋值，让ret也指向这个资源，把ret不要的资源换给临时对象让它一并带走
以是我们之前说的move本质就是把左值酿成右值的属性，调用移动赋值淘汰深拷贝

1.   String(String&& s)
2.         : _data(s._data)
3.         , _size(s._size)
4.         {
5.         s._data= nullptr;
6.         s._size= 0;
7.         }
9.    String& operator=(String&& s)  {
10.         if (this != &other)
11.         {
12.             delete[] _data;   
13.             _data= s._data;
14.             _size= s._size;
15.             s._data= nullptr;
16.             s._size= 0;
17.         }
18.         return *this;
19.     }

复制代码

1. int main()
2. {
3.         string ret ;
4.         ret = add("1", "2");
5.         string arr=move(ret);
6.         return 0;
7. }

复制代码

C++11里面的swap也支持了移动构造和移动赋值 
STL的容器在C++11都支持了移动构造和移动赋值

插入也支持了移动构造和移动赋值

 注意：右值被右值引用引用以后的属性是左值

1. int main()
2. {
3.         int&& r = 10;
4.         int p = r;
5.         cout << p << endl;
6. }

复制代码

这是编译器的逼迫修改
3.3函数模板：万能引用

1. void Func(int&& x)
2. {
3.         cout << "右值引用" << endl;
4. }
5. void Func(int& x)
6. {
7.         cout << "左值引用" << endl;
8. }
9. template <class T>
10. void Print(T&& x)
11. {
12.         Func(x);
13. }
14. int main()
15. {
16.         int a = 0;
17.         Print(a);
18.         Print(std::move(a));
19. }

复制代码

1. void Print(T&& x)
2. {
3.         Func(x);
4. }

复制代码

但是这里的func因为是右值被右值引用以是x酿成了左值，如果我们move改一下又全部酿成了右值

1. void Print(T&& x)
2. {
3.         Func(move(x));
4. }

复制代码

1. void Print(T&& x)
2. {
3.         Func(forward<T>(x));
4. }

复制代码

以是库里面就有了forward这个完美转化，保持实参的属性

如果它不是模板是平常函数就不能左值是左值引用右值是右值引用了

不是模板就只是右值引用了
而且C++类中的默认成员函数也到场了移动构造函数和移动赋值运算符重载
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下:
如果你没有自己实现移动构造函数，且没有实现析构函数，拷贝构造，拷贝赋值重载(都没写)的恣意一个。那么编译器会自动天生一个默认移动构造。默认天生的移动构造函数，对于内置范例会执行逐成员按字节拷贝，自界说范例成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造
移动赋值也是跟上面一样
如果你提供了移动构造和移动赋值，编译器不会自动提供拷贝构造和拷贝赋值
看起来很严酷现实上也是很合理的，因为你如果自己实现了析构函数，就代表你要完成深拷贝，那默认提供给你的移动构造也是完不成什么东西的
3.4default关键字

1. class People
2. {
3. public:
5.         People(const char* name = "", int age = 0)
6.                 :_name(name)
7.                 ,_age(age)
8.         {
9.                 cout << "构造" << endl;
10.         }
11.        
12.         People(const People&p)
13.                 :_name(p._name)
14.                 , _age(p._age)
15.         {
16.                 cout << "拷贝构造" << endl;
17.         }
18.         //People& operator=(const People& p)
19.         //{
20.         //        if (this != &p)
21.         //        {
22.         //                _name = p._name;
23.         //                _age = p._age;
24.         //        }
25.         //        cout << "拷贝赋值" << endl;
26.         //        return *this;
27.         //       
28.         //}
29.         People& operator=(const People& p) = default;
30. private:
31.         string _name;
32.         int _age;
33. };
34. int main()
35. {
36.         People p("人");
37.         People pp;
38.         pp = p;
39.         return 0;
40. }

复制代码

这个default就是让编译器逼迫天生好比说这个拷贝赋值
3.5delete关键字

1.         People& operator=(const People& p) = delete;

复制代码

相反的这个delete就是不让它天生 
四、可变参数模板

就是可以传入恣意多个参数
Args是一个模板参数包，args是一个函数形参参数包
声明一个参数包Args...args，这个参数包可以包罗0到恣意个模板参数

1. template<class ...Args>
2. void List(Args... args)
3. {
4.         cout << sizeof...(args) << endl;
5. }
6. int main()
7. {
8.         List(1);
9.         List(1,1.1);
10.         List(1,1.1,'x');
11. }

复制代码

1. cout << sizeof...(args) << endl;

复制代码

这个...是规定

可以盘算你的参数包有几个参数
那我们想要解析这个参数包该怎么办呢

1. void _List()
2. {
3.         cout << endl;
4. }
5. template<class T,class ...Args>
6. void _List(const T& val, Args... args)
7. {
8.         cout << val << " ";
9.         _List(args...);
10. }
11. template<class ...Args>
12. void List(Args... args)
13. {
14.         _List(args...);
15. }
16. int main()
17. {
18.         List(1);
19.         List(1,1.1);
20.         List(1,1.1,'x');
21. }

复制代码

这算是一个编译时的递归推演
假设一开始我们有三个参数包，传给list，然后_list会把它分成一个参数包和两个参数包，打印第一个，再分解剩下两个参数包，又会分成一个和另一个，到0个就不会继续往下推了，然后调用换行就结束了

第一个模板参数一次解析后去参数值

1. template<class T>
2. int Print(T t)
3. {
4.         cout << t << " ";
5.         return 0;
6. }
7. template<class ...Args>
8. void List(Args... args)
9. {
10.         int arr[] = { Print(args)... };
11.         cout << endl;
12. }
13. int main()
14. {
15.         List(1);
16.         List(1,1.1);
17.         List(1,1.1,'x');
18. }

复制代码

也就相当于这里你要初始化arr，知道它的大小，你就必须让编译器强行解析参数包，参数包有几个参数，Print就依次推演天生几个
五、lamda表达式

1. struct Books
2. {
3.         string _name;  // 名字
4.         double _price; // 价格
5.         int _evaluate; // 评价
6.         //...
8.         Books(const char* str, double price, int evaluate)
9.                 :_name(str)
10.                 , _price(price)
11.                 , _evaluate(evaluate)
12.         {
13.         }
14. };
17. struct ComparePriceLess
18. {
19.         bool operator()(const Books& gl, const Books& gr)
20.         {
21.                 return gl._price < gr._price;
22.         }
23. };
25. struct ComparePriceGreater
26. {
27.         bool operator()(const Books& gl, const Books& gr)
28.         {
29.                 return gl._price > gr._price;
30.         }
31. };
33. int main()
34. {
35.         vector<Books> v = { { "哈利波特", 22.1, 5 }, { "西游记", 30, 4 }, { "红楼梦", 32.2, 3 }, { "三国演义", 41.5, 4 } };
36.         sort(v.begin(), v.end(), ComparePriceLess());
37.         sort(v.begin(), v.end(), ComparePriceGreater());
38. }

复制代码

像这种类进行比力的时候我们都要专门写一个仿函数来支持它，但是如果参数过多大概仿函数的名字写的比力令人混淆就会引出很多的标题以是引入了lamda表达式
5.1lambda表达式书写格式：
[capture-list] (parameters) mutable-> return-type{statement}
[capture-list]：捕捉列表。该列表总是出如今lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
(parameters)：参数列表。与平常函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
mutable：默认环境下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略（即使参数为空）
->return-type：返回值范例。用追踪返回范例形式声明函数的返回值范例，没有返回值时此部分可以省略。返回值范例明确环境下,也可省略，由编译器对返回范例进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕捉到的变量。

打×的可以不写，打勾×的可写可不写

1.         auto f=[](int x)->int {cout << x << endl; return 0; };
2.         f(50);
3.         auto f1 = [](int x)
4.                 {
5.                         cout << x << endl; return 0;
6.                 };
7.         f1(20);

复制代码

这是一个函数对象，我们可以用auto来自动推导它的范例，返回值也可以不写，lamda也会自动推导出它的返回值
因为它团体而言是一个语句以是也要加；

1. sort(v.begin(), v.end(), [](const Books& b1, const Books& b2)->bool {return b1._price < b2._price; });

复制代码

我们上面的比力函数就不消写仿函数了，这样也清楚明了，是按价格的升序比力
这里就不消加；上面谁人因为他是一条语句的结束，但是这里它是一个对象

1. auto f=[](int x)->int {cout << x << endl; return 0; };
2. f(50);
3. cout << typeid(f).name() << endl;
4. auto f1 = [](int x){cout << x << endl; return 0;};
5. cout << typeid(f1).name() << endl;

复制代码

这个类的名字 <lamda_uuid> uuid是根据算法来的
但是f不能赋值给f1因为它们两个是差别的范例
5.2捕捉列表阐明
捕捉列表描述了上下文中那些数据可以被lamda使用，以及使用的方式传值还是传引用
[var]：表现值传递方式捕捉变量var。
[=]：表现值传递方式捕捉所有父作用域中的变量（成员函数包罗this指针）。
[&var]：表现引用传递捕捉变量var。
[&]：表现引用传递捕捉所有父作用域中的变量（成员函数包罗this指针）。
[this]：表现值传递方式捕捉当前的this指针。
注意：
父作用域指的是包罗lambda函数的语句块。
语法上捕捉列表可由多个捕捉项组成，并以逗号分割。好比[=, &a, &b]。
捕捉列表不允许变量重复传递，否则会导致编译错误。好比[=, a]重复传递了变量a。
在块作用域以外的lambda函数捕捉列表必须为空，即全局lambda函数的捕捉列表必须为空。
在块作用域中的lambda函数仅能捕捉父作用域中的局部变量，捕捉任何非此作用域大概非局部变量都会导致编译报错。
lambda表达式之间不能相互赋值，即使看起来范例雷同。

1.         int x = 1, y = 2;
2.         auto f = [](int& i, int& j)
3.                 {
4.                         int tmp = i;
5.                         i = j;
6.                         j = tmp;
7.                 };
8.         f(x, y);

复制代码

我们可以传参已往使用 

1.         auto f1 = [x, y]()
2.         {
3.                         int tmp = x;
4.                         x = y;
5.                         y = tmp;
6.         };
7.         f1();

复制代码

 
我们捕捉过来的就酿成了这个类的成员变量但是成功成员变量是const修饰的const修饰的就不能修改以是我们就要加一个mutable让它酿成可变的

1.         x = 0, y = 1;
2.         auto f1 = [x, y]()mutable
3.         {
4.                         int tmp = x;
5.                         x = y;
6.                         y = tmp;
7.         };
8.         f1();
9.         cout << x << " " << y << " " << endl << endl;

复制代码

但是我们运行以后会发现它们两个根本就没有互换

1.         x = 0, y = 1;
2.         cout << &x << " " << &y << endl;
3.         auto f1 = [x, y]()mutable
4.         {
5.                         cout << &x << " " << &y << endl;
6.                         int tmp = x;
7.                         x = y;
8.                         y = tmp;
9.         };
10.         f1();
11.         cout << x << " " << y << " " << endl << endl;

复制代码

相当于一种传值传参，

2.         x = 0, y = 1;
3.         cout << &x << " " << &y << endl;
4.         auto f1 = [&x, &y]()mutable
5.         {
6.                         cout << &x << " " << &y << endl;
7.                         int tmp = x;
8.                         x = y;
9.                         y = tmp;
10.         };
11.         f1();
12.         cout << x << " " << y << " " << endl << endl;

复制代码

加一个以引用捕捉就好了，拿外面的x，y来初始化自己

这里指出捕捉的变量是自己所处的父作用域

1.         int x = 1, y = 2, z = 3;
2.         auto f2 = [=, &z]()
3.                 {
4.                         z++;
5.                         cout << x << endl;
6.                         cout << y << endl;
7.                         cout << z<< endl;
8.                 };
9.         f2();

复制代码

=就即是是全部传值捕捉

1. class A
2. {
3. public:
4.         void func()
5.         {
6.                 auto f2 = [=]()
7.                         {
8.                                 cout << a1 << endl;
9.                                 cout << a2 << endl;
10.                         };
11.                 f2();
12.         }
13. private:
14.         int a1=1;
15.         int a2=1;
17. };

复制代码

这个就是捕捉this指向的成员变量
lamda的底层原理其实是仿函数
六、function包装器和bind

6.1funtion包装器
包装器包装的其实是可调用对象分别是:
函数指针
仿函数
lambda
函数指针的缺点是太复杂，看不懂
仿函数的缺点是太重了写一个比力还要去专门实现一个类
lamda的缺点是无法搞范例，范例是匿名的，差别的时间点差别的编译器范例都是不一样的

1. //类模板原型如下
2. template<class T>function;
3. template<class Ret,class...Args>
4. class function<Ret(Args...)>;

复制代码

Ret：被调用函数的返回范例
Args...被调用函数的形参

1. void swap_func(int& i, int& j)
2. {
3.         int tmp = i;
4.         i = j;
5.         j = tmp;
6. }
7. struct Swap
8. {
9.         void operator()(int& i, int& j)
10.         {
11.                 int tmp = i;
12.                 i = j;
13.                 j = tmp;
14.         }
15. };
16. int main()
17. {
18.         int x = 1, y = 2;
19.         auto swaplamda = [](int& i, int& j)
20.                 {
21.                         int tmp = i;
22.                         i = j;
23.                         j = tmp;
24.                 };
25.         function<void(int&, int&)> f1 = swap_func;
26.         cout << x << " " << y << endl << endl;
27.         function<void(int&, int&)> f2 = Swap();
28.         cout << x << " " << y << endl << endl;
29.         function<void(int&, int&)> f3 = swaplamda;
30.         cout << x << " " << y << endl << endl;
31. }

复制代码

我们可以对任何可调用对象进行包装
funtion把上面三种比力方法包装成一种统一的范例，如今我们来看一种实用例子

1.         map<string, function<void(int&, int&)>> cmdop = {
2.                 {"仿函数",Swap()},
3.                 {"函数指针",swap_func},
4.                 {"lamda",swaplamda}
5.         };
6.         cmdop["函数指针"](x, y);
7.         cout << x << " " << y << endl << endl;
8.         cmdop["仿函数"](x, y);
9.         cout << x << " " << y << endl << endl;
10.         cmdop["lamda"](x, y);
11.         cout << x << " " << y << endl << endl;

复制代码

6.2包装成员函数
成员函数取地址比力特殊，要加一个类域和取地址

1. class Func
2. {
3. public:
4.         static int plusi(int a, int b)
5.         {
6.                 return a + b;
7.         }
8.          double plusd(double a, double b)
9.         {
10.                 return a + b;
11.         }
12. };
13. int main()
14. {
15.         function<int(int, int)> f1 = &Func::plusi;
16.         cout << f1(1, 2) << endl;
17.         function<double(Func*,double, double)> f2 = &Func::plusd;
18.         Func fu;
19.         cout<<f2(&fu, 1.1, 2.2)<<endl;
21.         function<double(Func, double, double)> f3 = &Func::plusd;
22.         cout << f3(Func(), 1.1, 2.2) << endl;
23.         return 0;
24. }

复制代码

不是静态的成员函数参数里面都会包罗一个隐藏的this指针以是我们要加进去
最后一个是一个是指针去调用里面的成员函数，最后一个是对象去调用里面的成员函数
但是成员函数我们每次都要传第一个成员参数，但是我们能不能不传啊，以是就有了bind
6.3bind
它也在function头文件里面
可以调解次序也可以调解个数
bind是一个函数模板，它就像一个函数包装器(适配器)，担当一个可调用对象，天生一个新的可调用对象来适应原对象的参数列表
调解参数次序

1. int Sub(int a, int b)
2. {
3.         return a - b;
4. }
5. int main()
6. {
7.         function<int(int, int)> f1 = Sub;
8.         cout << f1(5, 2) << endl;
10.         function<int(int, int)> f2 = bind(Sub,placeholders::_2,placeholders::_1);
11.         cout << f2(5, 2) << endl;
12.         return 0;
13. }

复制代码

placeholder相当于一个标识符

调解参数个数，有些参数可以bind时写死

1.         function<int(int)> f3 = bind(Sub, 20, placeholders::_1);
2.         cout << f3(5) << endl;

复制代码

 这就能解决我们上面总是要传成员参数的标题了

1. function<double(double, double)> f4 = bind(&Func::plusd,Func(),placeholders::_1,placeholders::_2);
2. cout << f4(1.1, 2.2) << endl;

复制代码

1. void Print(int a, int b, int c)
2. {
3.         cout << a << endl;
4.         cout << b << endl;
5.         cout << c << endl;
6. }
7. int main()
8. {
9.         function<void(int, int)> f1 = bind(Print, placeholders::_1, 10, placeholders::_2);
10.         f1(1, 2);
11. }

复制代码

也可以bind中心谁人参数，这里传的placeholde_1/2r代表的是第一个实参还是第二个实参

希望对大家有所帮助

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。