【C++】关于C++11系列，你需要知道这些事——C++11最全系列讲解（上篇）

目录

一、C++11内容简介

二、初始化表达式

2.1 C++98中{}的初始化问题

2.2 内置类型的列表初始化

2.3 自定义类型的列表初始化

补充：std::initializer_list

三、 声明

3.1 auto

 3.2 decltype

补充：C++11后越界检查

四、（重点）右值引用和移动语义

4.1什么是左值、右值？

左值

右值

4.2左值引用与右值引用比较

左值引用总结：

右值引用总结：

4.3 右值引用使用场景和意义

4.4右值引用引用左值及其一些更深入的使用场景分析

 五、完美转发

完美转发实际中的使用场景：

---

一、C++11内容简介

        在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为 C++11之前的最新C++标准名称。不过由于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 能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅 功能更强大，而且能提升程序员的开发效率 。

---

二、初始化表达式

2.1 C++98中{}的初始化问题

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

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

对于一些自定义的类型，却无法使用这样的初始化。比如：

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

      就无法通过编译，导致每次定义vector时，都需要先把vector定义出来，然后使用循环对其赋初始值，非常不方便。C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

2.2 内置类型的列表初始化

int main()
{
// 内置类型变量
int x1 = {10};
int x2{10};
int x3 = 1+2;
int x4 = {1+2};
int x5{1+2};
// 数组
int arr1[5] {1,2,3,4,5};
int arr2[]{1,2,3,4,5};
// 动态数组，在C++98中不支持
int* arr3 = new int[5]{1,2,3,4,5};
// 标准容器
vector<int> v{1,2,3,4,5};
map<int, int> m{{1,1}, {2,2,},{3,3},{4,4}};
return 0;
}

注意：列表初始化可以在{}之前使用等号，其效果与不使用=没有什么区别。

但是实话实说，虽然可以省略括号，但是我们并不建议这样用，因为加上等号之后更可以体现出代码的规范性。

2.3 自定义类型的列表初始化

这里我们先以日期类举例，看到自定义类型初始化列表的情况。

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

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Point p1 = { 1, 2 };
	Point p2 { 1, 2 };
	int x1 = 1;
	int x2{ 2 };
	// !!!
	int* p3 = new int[4]{0};
	int* p4 = new int[4]{1,2,3,4};

	Date d1;
	Date d2(2022, 1, 17);
	// 这里虽然可以这么用，但是我们建议大家用，这种用法是为其他地方准备的
	Date d3{2022, 1, 18};
	Date d4 = { 2022, 1, 18 };


	return 0;
}

补充：std::initializer_list

文档介绍链接：initializer_list - C++ Reference

 那么这个到底是什么类型呢？

我们看到的是 initializer_list  可以进行大括号进行初始化。那么这个容器到底有什么用呢？我们来看一下下面的这几个赋值

vector<int> v = { 1, 2, 3, 4, 5 };
list<int> lt { 10, 20, 30};
vector<Date> vd = { { 2022, 1, 17 }, Date{ 2022, 1, 17 }, { 2022, 1, 17 } };
map<string, int> dict = { make_pair("sort", 1), { "insert", 2 } };

这里你会发现，这些都可以进行大括号赋值，那么为什么会出现这种情况呢，显然，这些都不是凭空支持的。

 

     显然，这里并不是C++11语法性质支持，而是每一个容器接口里面都有一个initializer_list的构造函数，大括号的列表直接就是一个initializer_list的类型，这个时候就会调用initializer_list的构造函数，把他的所有值取出来，然后一个一个进行赋值。

我们可以尝试用Vector模拟实现initializer_list。

这里我们可以进行模拟实现以下：

namespace self
{
	template<class T>
	class vector {
	public:
		typedef T* iterator;

		vector(initializer_list<T> l)
		{
			_start = new T[l.size()];
			_finish = _start + l.size();
			_endofstorage = _start + l.size();

			iterator vit = _start;
			/*typename initializer_list<T>::iterator lit = l.begin();
			while (lit != l.end())
			{
				*vit++ = *lit++;
			}*/

			for (auto e : l)
			   *vit++ = e;
		}

		vector<T>& operator=(initializer_list<T> l) {
			vector<T> tmp(l);
			std::swap(_start, tmp._start);
			std::swap(_finish, tmp._finish);
			std::swap(_endofstorage, tmp._endofstorage);

			return *this;
		}
	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};

        就是通过start，finish ，size（），这三个接口来进行赋值内容的记录，实现用大括号给其内容赋值的工作。

---

三、 声明

c++11提供了多种简化声明的方式，尤其是在使用模板时。

3.1 auto

                                       

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局

部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将

其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初

始化值的类型。

int main()
{
int i = 10;
auto p = &i;
auto pf = strcpy;
cout << typeid(p).name() << endl;
cout << typeid(pf).name() << endl;
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = dict.begin();
auto it = dict.begin();
return 0; }

 3.2 decltype

关键字decltype将变量的类型声明为表达式指定的类型。

#include<iostream>
using namespace std;
// decltype的一些使用使用场景
template<class T1, class T2>
void F(T1 t1, T2 t2) {
	decltype(t1 * t2) ret;
	cout << typeid(ret).name() << endl;
}
int main()
{
	const int x = 1;
	double y = 2.2;
	decltype(x * y) ret; // ret的类型是double
	decltype(&x) p;// p的类型是int *
	cout << typeid(ret).name() << endl;
	cout << typeid(p).name() << endl; F(1, 'a');
	return 0;
}

总而言之，用的还是比较少的，大概就是可以进行推演。

一些特定的使用场景：

template<class T1, class T2>
void F(T1 t1, T2 t2)
{
	decltype(t1 * t2) ret;
	cout << typeid(ret).name() << endl;

}

void f(int)
{
	cout << "void f(int)" << endl;
}

void f(int*)
{
	cout << "void f(int*)" << endl;
}

int main()
{

	const int x = 1;
	double y = 2.2;
	decltype(x * y) ret; // ret的类型是double
	//auto ret = x*y;
	decltype(&x) p;      // p的类型是int*
	cout << typeid(ret).name() << endl;
	cout << typeid(p).name() << endl;
	f(NULL);
	f(nullptr);
	F(x, y);

	return 0;
}

 

根据函数重载，可以看出哪些是指针（nullptr），哪些是整型。

3.3 nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示

整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

补充：C++11后越界检查

前期在越界时候，如果出现了不过分的越界现象，编译器不一定能查出，但是C++11之后，出现了更加严格的与业界检查标准。

int main()
{
	// 越界检查更标准严格
	array<int, 10> a1;
	array<int, 20> a2;
	//a1[11];
	//a1.at(11);

	int a3[10];
	a3[11];//未检查出

	vector<int> v;
	v.resize(10);

	return 0;
}

在没有放开注释部分之前，虽然有警告，但是并没有出现报错，传统定义的数组a3越界但是编译器没有检查出来。

 当把注释部分放开之后我们发现，直接出现了越界报错，array定义的在C++11标准，有了更加严格的越界检查。

 

---

四、（重点）右值引用和移动语义

4.1什么是左值、右值？

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们

之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

左值

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋

值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左

值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main()
{
// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;
return 0; }

右值

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引

用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能

取地址。右值引用就是对右值的引用，给右值取别名。

int main()
{
double x = 1.1, y = 2.2;
// 以下几个都是常见的右值
10; x + y;
fmin(x, y);
// 以下几个都是对右值的右值引用
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
10 = 1; x + y = 1;
fmin(x, y) = 1;
return 0; }

         需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可 以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地 址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，

这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

int main()
{
 double x = 1.1, y = 2.2;
 int&& rr1 = 10;
 const double&& rr2 = x + y;
 rr1 = 20;
 rr2 = 5.5;  // 报错
 return 0; 
}

4.2左值引用与右值引用比较

左值引用总结：

1. 左值引用只能引用左值，不能引用右值。

2. 但是const左值引用既可引用左值，也可引用右值.

int main()
{
    // 左值引用只能引用左值，不能引用右值。
    int a = 10;
    int& ra1 = a;   // ra为a的别名
    //int& ra2 = 10;   // 编译失败，因为10是右值
    // const左值引用既可引用左值，也可引用右值。
    const int& ra3 = 10;
    const int& ra4 = a;
    return 0; 
}

右值引用总结：

1. 右值引用只能右值，不能引用左值。

2. 但是右值引用可以move以后的左值。

int main()
{
 // 右值引用只能右值，不能引用左值。
 int&& r1 = 10;
 
 // error C2440: “初始化”: 无法从“int”转换为“int &&”
 // message : 无法将左值绑定到右值引用
 int a = 10;
 int&& r2 = a;
 // 右值引用可以引用move以后的左值
  int&& r3 = std::move(a);
 return 0; 
}

4.3 右值引用使用场景和意义

      前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引 用呢？是不是化蛇添足呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！

首先我们把string之前自己写的模拟实现导入进来，代码如下：

namespace Self
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			string tmp(s._str);
			swap(tmp);
		}

		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			this->swap(s);
		}

		// 移动赋值 
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			this->swap(s);

			return *this;
		}

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);

			return *this;
		}	

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;

				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};

	Self::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}

		Self::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;

			str += ('0' + x);
		}

		if (flag == false)
		{
			str += '-';
		}


		std::reverse(str.begin(), str.end());
		return str;
	}
}

传左值的意义：

1.做参数

// 左值引用的使用场景
// 1、做参数 
// 2、做返回值
void func1(bit::string s)
{}

void func2(const bit::string& s)
{}

int main()
{
	Self::string s1("hello world");
	// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
	func1(s1);
	func2(s1);

	return 0;
}

在调用f（1),f(2),一个是传值，一个是传引用。

如果传参是传值的话，那么这里就会涉及到深拷贝的问题，而这个地方我们进行取别名，就会减少一次拷贝。

2.做返回值

 

int main() 
{Self::string s1("hello world");
	s1 += 'A';
	return 0;
}

---

但是你会发现to_string 不能用左值引用返回，这个就是左值引用短板
如果函数返回对象除了函数作用域就不在了，就不能使用做引用返回，就会存在拷贝。

 

一般编译器优化之后，进行一次深拷贝，代价比较大。

 这个时候我们应该如何来进行优化呢，这个时候就需要用到右值引用了。

我们再对右值加深这里我们仿照拷贝赋值，让他于拷贝形成一个对比，再写一个移动赋值

这里我们多一层理解，右值分为两类：

1.纯的右值，如10；x+y；

2.临时创建的对象，将要销毁的返回值。

  优化的点在哪里呢？

右值引用和移动语义解决上述问题：

在bit::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不

用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

 

再运行上面self::to_string的两个调用，我们会发现，这里没有调用深拷贝的拷贝构造，而是调用

了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了。

我们再进行一次测试：

// 移动赋值
string& operator=(string&& s) {
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this; }
int main()
{
 Self::string ret1;
 ret1 = Self::to_string(1234);
 return 0; }
// 运行结果：
// string(string&& s) -- 移动语义
// string& operator=(string&& s) -- 移动语义

          运行结果如上，我们不难发现这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象 接收，编译器就没办法优化了。self::to_string函数中会先用str生成构造生成一个临时对象，但是 我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时 对象做为Self::to_string函数调用的返回值赋值给ret1，这里调用的移动赋值。

补充内容：STL 中的容器都是增加了移动构造和移动赋值：

http://www.cplusplus.com/reference/string/string/string/

http://www.cplusplus.com/reference/vector/vector/vector/

int main()
{
	list<std::string> lt;

	std::string s1("1111");
	// 这里调用的是拷贝构造
	lt.push_back(s1);

	// 下面调用都是移动构造
	lt.push_back("2222");
	lt.push_back(std::string("2222"));
	lt.push_back(std::move(s1));

	return 0;
}

4.4右值引用引用左值及其一些更深入的使用场景分析

     按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能 真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move

函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，

它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
// forward _Arg as movable
 return ((typename remove_reference<_Ty>::type&&)_Arg);
}
int main()
{
 Self::string s1("hello world");
 // 这里s1是左值，调用的是拷贝构造
Self::string s2(s1);
 // 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
 // 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
 // 资源被转移给了s3，s1被置空了。
 bit::string s3(std::move(s1));
 return 0; }

下图为优化图解，其本质原理大概为：

总结：

右值引用出来以后，并不是直接使用右值引用去减少拷贝，提高效率。而是支持深拷贝的类，提供移动构造和移动赋值，这时这些类的对象进行传值返回或者是参数为右值时，则可以用移动构造和移动赋值，转移资源，避免深拷贝，提高效率。

 五、完美转发

模板中的 && 万能引用

我们先来看下面一组代码：

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
std::forward 完美转发在传参的过程中保留对象原生类型属性
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; }

按说应该是按照上面的注释中的左右值进行输出，但是结果是什么呢？我们看到的是

 这是为什么呢？

 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发。

这个时候咋办？我们引进一个  std::forward

其作用为:完美转发在传参的过程中保留对象原生类型属性.

 

完美转发实际中的使用场景：

这里我们以链表为例，我们进行详细看一下

template<class T>
struct ListNode
{
 ListNode* _next = nullptr;
 ListNode* _prev = nullptr;
 T _data;
};
template<class T>
class List
{
 typedef ListNode<T> Node;
public:
 List()
 {
 _head = new Node;
 _head->_next = _head;
 _head->_prev = _head;
 }
 void PushBack(T&& x)
 {
 //Insert(_head, x);
 Insert(_head, std::forward<T>(x));
 }
 void PushFront(T&& x)
 {
 //Insert(_head->_next, x);
 Insert(_head->_next, std::forward<T>(x));
 }
 void Insert(Node* pos, T&& x)
 {
 Node* prev = pos->_prev;
 Node* newnode = new Node;
 newnode->_data = std::forward<T>(x); // 关键位置
 // prev newnode pos
 prev->_next = newnode;
 newnode->_prev = prev;
 newnode->_next = pos;
 pos->_prev = newnode;
 }
 void Insert(Node* pos, const T& x)
 {
 Node* prev = pos->_prev;
 Node* newnode = new Node;
 newnode->_data = x; // 关键位置
 // prev newnode pos
 prev->_next = newnode;
newnode->_prev = prev;
 newnode->_next = pos;
 pos->_prev = newnode;
 }
private:
 Node* _head;
};
int main()
{
 List<bit::string> lt;
 lt.PushBack("1111");
 lt.PushFront("2222");
 return 0; }

int main()
{
	List<Self::string> lt;
	Self::string s1("1111");
	lt.PushBack(s1);

	lt.PushBack("1111");
	lt.PushFront("2222");


	list<std::string> lt;
	
	std::string s1("1111");
	 //这里调用的是拷贝构造
	lt.push_back(s1);
	
	// 下面调用都是移动构造
	lt.push_back("2222");
	lt.push_back(std::string("2222"));
	lt.push_back(std::move(s1));

	return 0;
}

在选择插入删除时候，调用模板，为了提高效率，就必须保证其原属性，那么这个时候就必须用到完美转发，在这里得以应用