【C++进阶】C++11的认识与学习

电玩女神 2024-04-22 12:14 56阅读 0赞

## 一.列表初始化 ##

这个要和构造函数的初始化列表区分开。

在C++11中，新增加了列表初始化，即可以用（=）\{\}，给所有的内置类型和自定义类型初始化（等号可有可无）。

在C++98中，new 出来的一个int指针可以直接初始化，但是当有多个对象时，就只能用循环初始化，C++11的列表初始化就解决了这个问题，可以用\{\}，给多个对象初始化。

class Date
    {
    public:
    	Date(int year, int month, int day)
    		:_year(year)
    		, _month(month)
    		, _day(day)
    	{
    		cout << "Date(int year, int month, int day)" << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    int main()
    {
    	int a = { 1 };  //列表初始化内置类型，加 = 号
    	int b{ 5 };  //不加 = 号
    	int* p1 = new int(2);  //初始化单个new的对象
    	int* p2 = new int[5] {1, 2, 3, 4, 5};  //初始化多个new的对象
    	Date d1 = { 2023,1,27 };  //列表初始化自定义类型，加 = 号
    	Date d2{ 2023,2,10 };   //列表初始化自定义类型，不加 = 号
    	cout << *p1 << endl;
    	for (int i = 0; i < 5; i++)
    		cout << p2[i] << " ";
    	cout << endl;
    	return 0;
    }

### std::initializer\_list ###

那列表初始化是怎么实现的呢？

我们来看看它的类型，可以用下面的代码查看

int main()
    {
        // the type of il is an initializer_list
        auto il = { 10, 20, 30 };
        cout << typeid(il).name() << endl;
        return 0;
    }

可以发现它是 initializer\_list 类型，下面是关于该类型的一些介绍

![e4f23ffad7bd44bf98d53de58d24ef31.png][]

initializer\_list 的底层其实有一个 start 指针和一个 finish 指针，分别指向数据的开始和末尾的下一个位置，其实在使用 \{\} 列表初始化时，就是在调用 initializer\_list 的构造函数，C++11为STL容器都添加了有 initializer\_list 的构造函数。

例如vector![4c8eae80b57d43b9b5399755bff71285.png][]

--------------------

## 二.auto，decltype和nullptr声明 ##

### auto ###

auto之前都用过，它可以自己推导变量的类型，但是它必须要初始化，否则无法推导。

auto仅仅只是占位符，编译阶段编译器根据初始化表达式推演出实际类型之后会替换auto。

### decltype ###

decltype也可以用来声明，和auto不同的是，它可以不初始化。

使用方法：decltype（） 变量

![8f25c122a8c84827b3feffefcf4d6f2c.png][]

### nullptr ###

C++中 NULL 直接被定义成了0 ，没有了指针属性，为了补上这个漏洞，定义 nullptr 为空指针

![2976d2fa7e184b12a1960c8138f6181a.png][]

![2dbb7c23e86b48b0be926dcfa8ea03e9.png][]

--------------------

## 三.右值引用和移动语义 ##

### 什么是左值？什么是右值？ ###

*  左值：可以取地址，一般情况下，值可以被修改，左值可以出现在赋值符号的左右边；例如变量名，解引用的指针
 *  右值：不可以取地址，右值只能出现在赋值符号的右边；例如字面常量，表达式，函数返回值

是否能取地址是左值和右值最大的区别。

![ef35de53c1ca4492914f7128593442c9.png][]

### 左值引用和右值引用 ###

*  左值引用：引用的是左值就是左值引用，左值引用可以做返回值，减少拷贝，提高效率，但是局部变量不可以左值引用返回；左值引用是一个 &
 *  右值引用：引用的是右值就是右值引用；右值引用是两个 &&

注意：

*  const 左值引用可以引用右值
 *  右值引用可以引用 move过的左值（move是一个库函数，可以把左值转换为右值）
 *  所以并不是左值引用只能引用左值，右值引用只能引用右值
 *  右值引用变量的属性仍会被编译器识别为左值

int fun(int x, int y)
    {
    	return x + y;
    }
    
    int main()
    {
    	int a = 10, b = 20;
    	int& r1 = a;  //左值引用
    	const int& r2 = 10;  //const 左值引用引用右值
    	int&& rr1 = fun(a , b);  //右值引用
    	int&& rr2 = move(a);  //右值引用引用move过的左值（注意，a仍然是左值，只不过是move返回的是一个右值）
    	//注意 rr1 rr2 的属性仍为左值 
    	return 0;
    }

### 右值引用的应用 ###

场景1

自定义类型中深拷贝的类中，必须传值返回的场景。

![159ad55824d344a498e53b70193e23b8.png][]

我们知道，当函数是传值返回时，会先创建一个临时对象（临时对象具有常属性），将数据拷贝一份给临时对象，然后临时对象返回，原来的那个对象销毁，这样要连续拷贝，如果是一个大的对象，那么将极大地影响效率，所以 vs 对这块做了优化，把连续拷贝直接合为一个拷贝，这样做确实会有效率的提升，但还是要拷贝，而且换成另一个平台可能并没有这个优化，所以右值引用就出来了，极大地改善了这方面的问题。

对于生命周期即将结束的值，我们称为将亡值

右值引用和移动语义。

移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己，这极大地提高了效率。

namespace bit
    {    
            // 移动构造
    		string(string&& s)
    			:_str(nullptr)
    			, _size(0)
    			, _capacity(0)
    		{
    			cout << "string(string&& s) -- 移动语义" << endl;
    			swap(s);
    		}
    		// 移动赋值
    		string& operator=(string&& s)
    		{
    			cout << "string& operator=(string&& s) -- 移动语义" << endl;
    			swap(s);
    			return *this;
    		}
    
    }
    bit::string func()
    {
    	bit::string str;
    	return str;
    }
    
    int main()
    {
    	bit::string ret;
    	ret = func();
    
    	return 0;
    }

上面代码会打印 "string& operator=(string&& s) -- 移动语义" ，但是 func 里的 str 是一个左值，并不是右值，为什么会调用移动赋值呢？

C++11中，这一块底层其实都调用了 move ，把左值属性变成右值属性。

场景2

容器的插入接口，如果插入对象是右值，可以利用移动构造转移资源给数据结构中的对象，也可以减少拷贝。

void func(string&& str)
    {
    	cout << "func(bit::string&& str)" << endl;
    }
    
    void func(string& str)
    {
    	cout << "func(bit::string& str)" << endl;
    }
    
    int main()
    {
    	string s1;
    	func(s1);
    	func(move(s1));
    
    	return 0;
    }

所以在C++11中，给每个容器中都增加了 以右值引用作为参数的接口。

![a0b5da8eb6f447c9a5dd591587ca2140.png][]

![3518d1a272c04f5eb7adeaed94d8a5b8.png][]

--------------------

## 四.完美转发 ##

### 模板中的&& 万能引用 ###

当 && 写在模板中，它就是万能引用，既可以是左值引用，也可以是右值引用。

下面来看这一段代码

void Fun(int& x) { cout << "左值引用" << endl; }
    void Fun(const int& x) { cout << "const 左值引用" << endl; }
    void Fun(int&& x) { cout << "右值引用" << endl; }
    void Fun(const int&& x) { cout << "const 右值引用" << endl; }
    
    template<class T>
    void PerfectForward(T&& t)
    {
    	Fun(t);
    }
    int main()
    {
    	PerfectForward(10);    //右值
    	int a;
    	PerfectForward(a);     //左值
    	PerfectForward(move(a)); // 右值
    	const int b = 8;
    	PerfectForward(b);     //const 左值
    	PerfectForward(move(b)); // const 右值
    	return 0;
    }

打印结果是什么？

![64768165fa9b4a36af6e266bfe0d2e14.png][]

答案出乎意料地全是左值引用。

前面已经说过，不管是左值引用变量还是右值引用变量，它们的属性都会被编译器识别为左值，所以全部打印出了左值引用 。

那要如何保留右值属性呢？

### std::forward 完美转发在传参的过程中保留对象原生类型属性 ###

// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
    template<class T>
    void PerfectForward(T&& t)
    {
        Fun(forward<T>(t));
    }

再来看看打印结果

![29f788b5d17a4bb7a6f80ecbea06adba.png][]

--------------------

## 五.final 和 override ##

### final ###

*  只能修饰类和虚函数
 *  修饰类时，表示该类不可以被继承
 *  修饰虚函数时，表示该虚函数不可以被重写

### override ###

*  作用发生在编译时
 *  override只能修饰子类的虚函数
 *  用于显式地表明派生类中的函数是重写基类中的虚函数。这可以确保派生类中的函数正确地重写了基类中的虚函数，并且可以避免一些程序错误。如果派生类中的函数没有正确地重写基类中的虚函数，则编译器会发出警告

--------------------

## 六.lambda表达式 ##

语法：\[capture-list\] (parameters) mutable -> return-type \{ statement\}

*  \[capture-list\] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据\[\]来  
    判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda  
    函数使用。
 *  (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以  
    连同()一起省略
 *  mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量  
    性。使用该修饰符时，参数列表不可省略(即使参数为空)。其实这个用的很少。
 *  \->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回  
    值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推  
    导。
 *  \{statement\}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获  
    到的变量。

下面就是一个简单的lambda表达式

auto swap1 = [](int x, int y) {return x + y; };

*  注意 lambda 表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量；
 *  参数列表和返回值类型都可以省略，但是参数列表 \[\] ，和函数体 \{\} ，不可以省略，所以最简单的 lambda 表达式为 \[\]\{\}

捕捉列表说明

*  \[val\]，表示值传递方式捕获某个变量
 *  \[=\]，表示值传递方式捕获所有父作用域中的变量(包括this)
 *  \[&var\]，表示引用传递捕捉变量var
 *  \[&\]，表示引用传递捕捉所有父作用域中的变量(包括this)
 *  以上捕捉方法都可以混合使用

int main()
    {
    	int a = 10, b = 20;
    	int c = 30, d = 40;
    	auto func1 = [a, b] {cout << a << " " << b << endl; };   //部分值传递
    	auto func2 = [=] {cout << a << " " << b << " " << c << " " << d << endl; };  //值传递捕获父域所有变量
    	auto func3 = [&a, &b] {a = 20, b = 10; };   //部分引用传递
    	auto func4 = [&] {a = 1, b = 2, c = 3, d = 4; };  //引用传递捕获父域所有变量
    
    	return 0;
    
    }

注意：

*  父作用域指包含lambda函数的语句块
 *  捕捉列表不允许变量重复传递，否则就会导致编译错误
 *  在块作用域以外的lambda函数捕捉列表必须为空
 *  lambda表达式之间不能相互赋值

其实，lambda表达式的底层是仿函数，即使两个lambda表达式看起来是一样的，但它们在底层仍然不同，不属于同一个类型

![11d26feaf3c14fc1afee22bc4bc21cf1.png][]

--------------------

## 七.新的类功能 ##

C++11之前，类有6个默认成员函数：

*  构造函数
 *  拷贝构造
 *  赋值重载
 *  析构函数
 *  取地址重载
 *  const 取地址重载

C++11后又新增加了两个默认成员函数：

*  移动构造函数
 *  移动赋值运算符重载

一些注意点：

*  如果没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任  
    意一个，那么编译器会自动生成一个默认移动构造。
 *  如果没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中  
    的任意一个，那么编译器会自动生成一个默认移动赋值。
 *  如果提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

--------------------

## 八.delete 的新作用 ##

C++11中，delete除了用来释放掉动态申请的资源外，还可以使编译器不自动生成默认的成员函数。

class A
    {
    public:
    	A(const A& a) = delete;   //禁止生成拷贝构造
    	A operator=(const A& a) = delete;  //禁止生成赋值重载
    };

## 九.包装器 ##

迄今为止，学过的可调用对象有3种：

*  函数指针
 *  仿函数
 *  lambda表达式

但是怎么把这三种对象存到一个对象里呢？

### function包装器 ###

包含在头文件 <functional> 中

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

Ret 是返回值类型，Args...是一个可变参数包，也就是可调用对象的参数类型

![7dda2f0c1f654e08a44871b61fc1c8cb.png][]

![18a4669cb0e746c4869c159659393e10.png][]

--------------------

## 十.bind 绑定 ##

## ![8cde08e7ccd7489b9c6b21a9a16d5439.png][] ##

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可  
调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。使用方法如上图所示。第一个参数是一个可调用对象，后面的参数是一个参数包。

它可以通过绑定一些参数，来调整参数的顺序。

C++的库中定义了一个命名空间：placeholders ，其中的\_1 \_2表示的是第几个参数，比如\_1表示的就是函数的第一个参数......

注意如果可调用对象是类的对象，那么要取地址。

如果可变参数写的是常数的话，那么就相当于缺省参数。

![ec7ef62f70744942be88f8634b98aa48.png][]

int sub(int a, int b)
    {
    	return a - b;
    }
    
    int main()
    {
        //把sub函数的参数顺序调换
    	function<int(int, int)> s = bind(sub, placeholders::_2, placeholders::_1);  
    	cout<<s(1, 2)<<endl;
    	cout << sub(1, 2) << endl;
    
    	return 0;
    }

![388f499ed14c4a3b9e2ea61ac6639f4c.png][]

--------------------

> **??本篇文章到此就结束了， 若有错误或是建议的话，欢迎小伙伴们指出；?️?**
> 
> **??希望小伙伴们能支持支持博主啊，你们的支持对我很重要哦；??**
> 
> **??谢谢你的阅读。??**

[e4f23ffad7bd44bf98d53de58d24ef31.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/27749aa9088947bf9546a8d19caf00c5.png
[4c8eae80b57d43b9b5399755bff71285.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/e523ce789c344743a8337e640f37e399.png
[8f25c122a8c84827b3feffefcf4d6f2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/24e875d039074bb2ae389cf93e0119fe.png
[2976d2fa7e184b12a1960c8138f6181a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/cdf72165a57e454786811b00b29802ab.png
[2dbb7c23e86b48b0be926dcfa8ea03e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/20a8007cdd734c428118bbf5f81cb342.png
[ef35de53c1ca4492914f7128593442c9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/03c8925682f0425599139d91a4daa9c1.png
[159ad55824d344a498e53b70193e23b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/f591b3377f07416684e2c602a454c39c.png
[a0b5da8eb6f447c9a5dd591587ca2140.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/3642167179114392a7ac7b33fdd0928d.png
[3518d1a272c04f5eb7adeaed94d8a5b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/088cb6b4148d46d1aa8161fccc199f28.png
[64768165fa9b4a36af6e266bfe0d2e14.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/ff42064239784e8daa5bfd59604e3f72.png
[29f788b5d17a4bb7a6f80ecbea06adba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/82d39bebb83d48319c6f907ac0e35813.png
[11d26feaf3c14fc1afee22bc4bc21cf1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/240187ff00fd4515a3c29e32ea7b805a.png
[7dda2f0c1f654e08a44871b61fc1c8cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/0e7dca2f319d431f9e8d26dcadd066dd.png
[18a4669cb0e746c4869c159659393e10.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/e650236fe27c4a6db8aa1ac9b3660887.png
[8cde08e7ccd7489b9c6b21a9a16d5439.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/765ce3951b3b400dbf3626a1629ff6f4.png
[ec7ef62f70744942be88f8634b98aa48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/a2d003299c2a41189bc7bf37f85006fd.png
[388f499ed14c4a3b9e2ea61ac6639f4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/9d11149c41fa4a329db89109cbf593bd.png