---

前言

在本篇文章，我们将会详细介绍一下C++11新增的一些特性，其中最重要的是右值引用，智能指针等，这其中也产生了很多不必要的语法设计。

一、C++11介绍

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于
C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中
约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，
C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更
强大，而且能提升程序员的开发效率，

https://en.cppreference.com/w/cpp/11

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于
C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中
约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，
C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更
强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个
重点去学习。C++11增加的语法特性非常篇幅非常多，我们这里没办法一 一讲解，所以本节课程

二、列表初始化

1.{}初始化

我们在C++98已经用过这个东西了，比如数组初始化，结构体初始化等

struct Point
{
	int _x;
	int _y;
};
int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	Point p = { 1, 2 };
	return 0;
}

C++11进一步扩展了 { } 的特性，一切皆可用 { }，无论是内置类型，还是自定义类型。
其中赋值（=）可以省略

内置类型

C++11，支持这样写

int a={1};
int b{1}；
//对于new的对象也可以
int *p=new int[5]{1,2,3,4,5};

内置类型

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
};

创建对象时也可以使用列表初始化的方式调用构造函数来初始化
我们在之前只能这样写
Date d1(1,1,1);拷贝构造

我们可以用C++的新语法
多参数隐式类型转化
Date d2={2,2,2};
Date d3{3,3,3};

2.initializer_list

我们之前学习过的容器，也可以用到{}初始化
比如：vector v{1,2,3,4,5};
本质是先构造，再拷贝构造，C++优化成直接构造

那它为什莫可以用这个呢？？
本质是用initializer_list拷贝了一份

其他的容器也实现了这个，这里就不过多阐述。
赋值也要进行实现

有了 initializer_list 类以后，我们就可以让 STL 的其他容器重载一个参数为 initializer_list 类型的构造函数和赋值函数，从而使得这些容器支持使用列表来进行初始化和赋值；

initializer_list底层是什么样子的呢？？

begin和end其实就是两个指针，就size记录元素个数。

三、auto与decltype

auto：自动推导类型

C++98中已经出现了auto,它的功能是将一个变量设置为临时的，自动申请，自动结束。我们在写代码时，发现不用加auto也是实现这个功能，我们就几乎不使用这个关键字了。

c++11赋予了auto新的含义，实现类型的自动推导，要求必须显式初始化，编译器在编译时根据对象的类型自动推导初始化类型。
比如：auto a=10;10为整形，编译器就根据10进行推导，编译时auto设为int.

不过我们一般不这样使用，我们一般用auto代替长类型。
比如：stack< int >iterator::it=st.begin(); 我们可以直接简化为auto it=st.begin();

auto在有些编译器下可以做返回值，但是我们及其不推荐。

decltype:将变量的类型声明为表达式指定的类型

int main()
{
	const int x = 10;
	double y = 3.14;
	decltype(x * y) ret = 10.3;
	cout << ret << endl;
	return 0;
}

我们通过decltype推导出ret的类型是（x*y）,也就是double,同时赋值为10.3。

我们常用于这种情况下

template<class T1, class T2>
void fun(T1 t1, T2 t2)
{
	decltype(t1 + t2)ret;
	cout << typeid(ret).name();
}

四、STL中变化

新容器

C++在C++11引入了几个容器，其中包括unordered_map,unordered_set,这两个是最实用的。
还有array(静态数组），forward_list(单链表)这两个我们在日常中不太会使用。

新接口

其中包括cbegin，cend,已经const迭代器中，这些设计无关痛痒，
其中移动构造，移动赋值，右值引用等意义十分重大。

五、右值引用

我们在之前已经学习过了引用，引用本质就是取别名，不开辟空间，但是底层是由指针实现的。

左值和左值引用

左值就是一个表达式，其中包括变量名，解引用的变量等等，他们都有可以取地址，可以被赋值，位于赋值运算符的左边。但是如果被const修饰，就不能被赋值。
左值引用就是对左值进行取别名。其中前置++也是左值。

//左值,其中ch,a,p都是左值
int ch=10;
const int a=ch;
int*p=new int(100);

//左值引用
int& rch=ch;
const int& ra=a;
int*&rp=p;

右值和右值引用

右值引用也是一个表达数据的表达式，包括字面常量，函数返回值，表达式结果等等，右值是不能被取地址的，也不能对他进行赋值操作。位于赋值运算符的右边。后置++
右值引用就是对右值进行取别名。

//常见右值
10；
x+y;
fun();

//右值引用
int&&ch1=10;
double&&ch2=x+y;
char&&ch3=fun();

注意: 右值不能被修改，也不能被取地址。但是被右值引用之后，就有了一块固定存储空间，我们就可以对他进行取地址，也可以对他修改。但如果不想进行修改，就加上const

比如：

左值引用与右值引用转换

🌟左值引用能用左值来进行引用，不能用右值。但是const 既可以用左值引用，也可以用右值引用。
左值引用存储的是当前地址。

int  main()
{
	//左值引用右值
	const int& ch1 = 10;
	
	//左值引用左值
	int a = 100;
	const int& ch2 = a;
	return 0;
}

🌟右值引用能用来引用右值，但不能引用左值。但是右值引用可以引用move后的左值。
move唯一的功能就是将一个左值强制转换成右值引用，实现移动语义。
右值引用存储的是栈上的一个临时空间的地址

int&& nn = move(a);

为什莫存在右值引用，引用本质就是用来减少拷贝的

我们之前学习过的左值引用已经减少了很多拷贝，比如：传参数，函数返回值的返回。

但是左值引用有一种场景还没有解决！！！如果函数的返回值是一个临时对象，出了作用域就销毁了，我们就不能用左值引用减少拷贝了，只能进行传参返回，不能减少拷贝。。

右值引用就是解决这样场景的。。

string to_string()
{
	string ret;
	//.....

	return ret;
}
int main()
{

	string s = to_string();
	return 0;
}

如果使用正常的左值引用我们来看一下，会产生两次拷贝，如果是深拷贝，资源浪费巨大。并且拷贝的这块临时空间还会被释放。也就是说，这块空间，刚被拷贝构造之后，再次拷贝构造，就会被立即释放掉。

返回的是一个临时对象(出了作用域就销毁)，返回时要先进行拷贝进一块临时空间，在用这个临时空间拷贝构造s

C++编译器对这种情况做了处理，只是部分主流编译器会做这样的处理
构造·+拷贝构造----->直接构造，省去了那次临时对象的拷贝

右值引用的移动语义：移动构造本质:将参数右值的资源窃取过来，占为己有。不用进行拷贝了。延长资源的生命周期

而右值引用对着做了进一步的优化
它是通过对构造函数进行处理，根据参数的匹配原则，如果拷贝构造的是右值（临时值），就走这个右值引用的拷贝构造

string(string&&sp)
{
	swap(sp);
}

我们画图来理解一下

s1(sp);将sp的资源进行转移到自己这里，出了作用域sp自动释放。

我们按照这种方式，进行了一次拷贝构造，传给临时对象，在将这个临时对象移动构造给s

但是再进行编译器的优化之后，构造和移动构造合二为一，变成直接移动构造
同时ret是左值，编译器会隐式的进行move(ret),变成右值。

这种实现方式是通过参数不同，函数不同的方式实现的（参数匹配）

void fun(int& ch)
{
	cout << "void fun(int& ch)" << endl;
}

void fun(int&& ch)
{
	cout << "void fun(int&& ch)" << endl;
}
int main()
{
	int a1 = 0;
	fun(a1);
	fun(1);
	return 0;
}

只有深拷贝的对象才需要移动拷贝

右值引用的移动语义还包括赋值，赋值也是同样的道理

string& operator=(string&& s)
{
	cout << "string& operator=(string&& s) -- 移动语义" << endl;
	swap(s);
	return *this;
}
string to_string()
{
	string ret;
	//.....

	return ret;
}
int main()
{
	bit::string ret1;
	ret1 = bit::to_string(1234);
	return 0;
}

使用右值引用的情况下，调用了一次移动构造，一次移动赋值。

C++11之后，很多容器都增加了移动构造和移动赋值。

STL容器插入接口也增加了右值引用版本


如果我们要插入的是左值，就去调用左值的插入。我们要插入右值，就调用右值的插入

不要轻易对左值进行move操作，除非你准备好这个左值的资源被拿走

我们可以发现s1的资源被s3拿走了，我们对s1进行操作时注意他已经没有资源了。

右值引用还有一个重要应用：完美转发与万能引用

什么是完美转发呢？？我们首先看一段代码

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<typename T>
void PerfectForward(T && t)
{
	Fun(t);
}

int main()
{
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b); // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

我们首先运行一下，看一下效果

我们发现全都是左值引用，这是为什么呢？？我们解决几个异或！！！

🌟我们写的模板可是右值引用的，为什么左值也可以调用呢？？

template< typename T>
void PerfectForward(T && t)

在函数模板中，我们的这个T&&t 是当作万能引用的，什么意思呢？？
我们不能单纯的把它理解为右值，只有传右值才进行调用，
而是传左值，就当作左值，传右值就当作右值。
只有与模板配合使用时才忽悠万能引用的功能

🌟我们传的是右值，为甚末也调用左值引用？？
我们传右值给t，右值引用，变为了左值的属性。
我们继续传递给Fun函数，也就是拿左值进行传递，当然调用左值。

如何解决？？

利用完美转发!!!
完美转发就是在传参过程中保持原来的属性不变，forward

template<typename T>
void PerfectForward(T && t)
{
	Fun(forward<T>(t));
}

我们再调用看看

我们就实现了我们想要的结果。

六.C++中关于类的新功能

移动构造与移动赋值运算符重载

在之前我们已经学习过六个默认成员函数------构造函数，析构函数，拷贝构造，拷贝赋值，取地址重载，const取地址重载，我们如果不写编译器会默认生成。

C++11提供了两个新的成员函数，移动拷贝与移动赋值

🌟移动构造：如果我们不写移动构造且没有写拷贝构造，析构函数，拷贝赋值（都没写），编译器将生成默认的移动构造。默认移动构造，对于内置类型完成值拷贝，对于自定义类型类型的成员，如果这个自定义类型实现了移动构造，就调用移动构造，如果没有，就调用拷贝构造。
🌟移动赋值：如果我们不写移动赋值且没有写拷贝构造，析构函数，拷贝赋值（都没写），编译器将生成默认的移动赋值。默认移动赋值，对于内置类型完成值拷贝，对于自定义类型类型的成员，如果这个自定义类型实现了移动赋值，就调用移动赋值，如果没有，就调用拷贝赋值。
🌟如果我们自己实现了移动构造或移动赋值，编译器将不会生成默认的。

类成员变量初始化

我们在类中定义成员变量时，可以给缺省值

class Date
{
private:
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

生成的默认构造函数会使用这些缺省值初始化

强制生成默认成员函数-----default

C++11可以让我们更好的控制默认成员函数。假设你要使用默认生成函数，但是由于某些原因，没有生成，调用了我们自己实现的。
这时我们就可以用default.
例子：我们提供了拷贝构造，不会生成默认移动构造，我们就可以用dafault强制生成默认移动构造
Person(Person&& p) = default;

禁止生成默认构造函数----delete

C++98中，如果我们想要限制某些成员函数的生成，可以将这个函数设置为私有，并且只声明不定义，就可以实现。其他人调用就会报错。

class A
{
private:
	A(int a, int b);
	int _a;
	int _b;
};

C++11中，只需要在函数声明上加上 =delete 就可以，编译器就不会生成对应函数的默认版本。

七.可变参数模板

为什么会有可变参数模板呢？？？
我们之前学习过的模板，传递的参数是固定的，如果我们想要写多个基本相同的函数，我们就需要写好几个模板。
C++11中可变参数模板允许我们传递可变参数的类模板和函数模板。

函数模板
template < class…Args> Args是一个模板参数包，这里面可以传递（0，N）个参数
void ShowList(Args… args); args是一个函数形参参数包

我们无法直接获取参数包里的每个参数，不允许使用args[ i ]的方式，因为这个解析参数时是在运行时。
而模板是在编译时。
我们只能通过展开参数包，获取每个参数，我们可以用到递归实现。

template<class T>
void fun(T value)
{
	cout << value << endl;
}

template<class T,class ...Args>
void fun(T value, Args ...args)
{
	cout << value << " ";
	fun(args...);
}

template<class ...Args>
void ShowList(Args ...args)
{
	fun(args...);
}

int main()
{
	ShowList(1);
	ShowList(1,'1');
	ShowList(1,'1',3.14);
	ShowList(1, '1', 3.14,string("xxxx"));


	return 0;
}

我们运行看一下

确实我们可以获取每一个参数，这是在编译时的递归。

应用： 我们的一大用处就是传递参数。看一个例子

class Date
{
public:
	Date(int year=1, int month=1, int day=1)
	{
		_year = year;
		_month = month;
		_day = day;

		cout << "	Date(int year=1, int month=1, int day=1)" << endl;
	}
	
private:
	int _year;
	int _month;
	int _day;
};


template <class ...Args>
void CreateDate(Args ...args)
{
	Date(args...);
}

我们在传递参数时候，可以传递不传参数，也可以传多个。

int main()
{
	Date d1();
	Date d2(2024);
	Date d3(2024, 1);
	Date d4(2024, 1,1);
	return 0;
}

逗号表达式展开参数包

printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。、
expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行
printarg(args)，再得到逗号表达式的结果0。
同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)…}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc… )，最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。
由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

template <class T>
void PrintArg(T t)
{
	cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
	int arr[] = { (PrintArg(args), 0)... };
	cout << endl;
}
int main()
{
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

容器中wmplace接口函数

emplace系列的接口，支持模板的可变参数，并且可以万能引用。

插入的是单个值，没有什么区别

看一下这种场景呢

一个是构造+移动拷贝，另一个是拷贝。其实二者之间并没有太大的差别。针对深拷贝的有移动构造的对象，效率提升不是很明显

对于浅拷贝呢？？

针对浅拷贝的类，如果写插入对象的参数，可以减少拷贝，直接构造

直接给插入对象参数的情况下:
emplace系列，针对浅拷贝的类，如果写插入对象的参数，可以减少拷贝，直接构造
emplace系列，深拷贝的类对象，减少一次移动构造浅拷贝的类对象，减少一次拷贝构造

八.lambda表达式

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法

#include <algorithm>
#include <functional>
int main()
{
	int array[] = { 4,1,8,5,3,7,0,9,2,6 };
	// 默认按照小于比较，排出来结果是升序
	std::sort(array, array + sizeof(array) / sizeof(array[0]));
	// 如果需要降序，需要改变元素的比较规则
	std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
	return 0;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
	3 }, { "菠萝", 1.5, 4 } };
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
}

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，
都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，
这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
	3 }, { "菠萝", 1.5, 4 } };
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price < g2._price; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price > g2._price; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate < g2._evaluate; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate > g2._evaluate; });
}

书写格式
[ 捕捉列表] (参数列表 ) mutable ->返回值{ 函数体}
🌟捕捉列表：这个必须写，编译器根据[ ] 来判断接下来的代码是否为lambda表达式，捕捉列表能够捕捉上下文变量供lambda函数使用
🌟参数列表：与函数参数一致，如果我们不需要传参，可以与（）一起省略掉
🌟mutable:默认情况下，lambda是一个const函数，mutable可以取消const属性。如果我们使用mutable，即使参数为空，我们也不能省略（）
🌟->返回值：如果没有返回值可以省略，有返回值也可以省略，这是编译器根据返回的类型自动推导。
🌟函数体：函数体内,除了使用参数外，还可以使用捕捉列表中的变量。

lambda表达式实际上是一个无名函数，该函数无法直接调用。
如果想要进行调用，可以借助auto赋值给一个变量

auto fun2 = [=, &b](int c)->int{return b += a+ c; };
cout<<fun2(10)<<endl;

我们来仔细看一下捕捉列表
🌟[ var ]:传值方式捕捉var
🌟[ = ]:传值捕捉lambda表达式中的作用域所有变量
🌟[ &var ]:传引用捕捉lambda
🌟[ & ]：传引用捕捉lambda表达式中的作用域所有变量
🌟[ this ]:传值捕捉this指针。
🌟可以捕捉多项，混合捕捉，逗号分隔。
🌟捕捉列表不允许变量重复传递，否则编译器报错。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
🌟lambda之间不能互相赋值。

lambda与仿函数

class Rate
{
public:
	Rate(double rate) : _rate(rate)
	{}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	// 函数对象
	double rate = 0.49;
	Rate r1(rate);
	r1(10000, 2);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;	};
	r2(10000, 2);
	return 0;
}

我们通过汇编看一下

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如
果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

总结

以上就是今天要讲的内容，本文仅仅详细介绍了C++新增的接口，容器的内容。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘