C++ 11新特性详解

你的名字 2023-09-26 09:47 82阅读 0赞

### 目录 ###

*  一、C++11
 *  二、列表初始化
 *   *  1. 列表初始化的使用
     *  2. 初始化列表的底层原理
 *  三、C++11新的声明
 *   *  1. auto
     *  2. decltype
     *  3. nullptr
 *  四、容器变化
 *   *  1. 新容器
     *  2. 容器中新增方法
 *  五、右值引用和移动语义
 *   *  1. 左值引用和右值引用
     *  2. 左值引用和右值引用的比较
     *  3. 右值引用的使用场景及意义
     *  4. 右值引用引用左值
     *  5. 完美转发
 *  六、类的新功能
 *   *  1. 默认成员函数
     *  2. 强制生成默认函数的关键字default
     *  3. 禁止生成默认函数的关键字delete
 *  七、Lambda表达式
 *  八、智能指针
 *  九、包装器
 *   *  1. 包装器的概念
     *  2. 为什么要有包装器
     *  3. bind

# 一、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能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率**，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。**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扩大了用**大括号**括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，**使用初始化列表时，可添加等号(=)，也可不添加**。

struct Point
    {
        
    	int _x;
    	int _y;
    };
    int main()
    {
        
    	int x1 = 1;
    	int x2{
         2 };
    	int array1[]{
         1, 2, 3, 4, 5 };
    	int array2[5]{
         0 };
    	Point p{
         1, 2 };
    	
    	// C++11中列表初始化也可以适用于new表达式中
    	int* pa = new int[4]{
         0 };
    	return 0;
    }

创建对象时也可以使用列表初始化方式调用构造函数初始化。

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()
    {
        
    	Date d1(2022, 1, 1); // old style
    	// C++11支持的列表初始化，这里会调用构造函数初始化
    	Date d2{
         2022, 1, 2 };
    	Date d3 = {
         2022, 1, 3 };
    	return 0;
    }

## 2. 初始化列表的底层原理 ##

初始化列表的底层套用的是std::initializer\_list。std::initializer\_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer\_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。[std::initializer\_list参考文档。][std_initializer_list]

例如：

*  list  
    ![c3c9c2131792489689453490c1f9a114.png][]
 *  vector  
    ![6fa72416e1fb45109ea50588370b17c7.png][]

# 三、C++11新的声明 #

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

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

使用auto可以使代码写起来更加的简单、便捷。

## 2. decltype ##

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

例如：

// 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;
    
    	int z = 0;
    	decltype(z) tmp;
    
    	cout << typeid(tmp).name() << endl;
    	F(1.1, 1.1);
    	return 0;
    }

## 3. nullptr ##

**由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。**

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

# 四、容器变化 #

## 1. 新容器 ##

![3ec4c3064ba14abfadd6678cee12117f.png][]  
用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered\_map和unordered\_set。  
unordered\_map和unordered\_set可见前面的文章：  
[【C++ unordered\_map和unordered\_set的使用】][C_ unordered_map_unordered_set]  
[【哈希原理及模拟实现并封装unordered系列关联式容器】][unordered]

## 2. 容器中新增方法 ##

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。  
实际上C++11更新后，容器中增加的新方法最后用的插入接口函数的右值引用版本：

[std::vector::emplace\_back][std_vector_emplace_back]  
[std::vector::push\_back][std_vector_push_back]  
[std::map::insert][std_map_insert]  
[std::map::emplace][std_map_emplace]  
…

**使用右值引用的版本可以提高效率，右值引用见下文。**

# 五、右值引用和移动语义 #

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

## 2. 左值引用和右值引用的比较 ##

1.  左值引用

> 1.  左值引用只能引用左值，不能引用右值。
> 2.  但是const左值引用既可引用左值，也可引用右值。

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

1.  右值引用

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

## 3. 右值引用的使用场景及意义 ##

既然左值引用既可以引用左值又可以引用右值，那么为什么C++11还要提出右值引用呢，下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！

这里以模拟实现的string为例。

namespace lhf
    {
        
    	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& operator=(const string& s)
    		{
        
    			cout << "string& operator=(string s) -- 深拷贝" << endl;
    			string tmp(s);
    			swap(tmp);
    			return *this;
    		}
    		// 移动构造
    		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;
    		}
    		~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
    	};
    }

**左值引用的使用场景：**  
做参数和做返回值都可以提高效率。

void func1(lhf::string s)
    {
        }
    void func2(const lhf::string& s)
    {
        }
    int main()
    {
        
    	lhf::string s1("hello world");
    
    	// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
    	func1(s1);
    	func2(s1);
    	// string operator+=(char ch) 传值返回存在深拷贝
    	// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
    
    	s1 += '!';
    	return 0;
    }

**左值引用的短板：**  
但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：  
**lhf::string to\_string(int value)** 函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

![2cf4400e8c5b4816b7d59da2c4c186a1.png][]

namespace lhf
    {
        
    	lhf::string to_string(int value)
    	{
        
    		bool flag = true;
    		if (value < 0)
    		{
        
    			flag = false;
    			value = 0 - value;
    		}
    		lhf::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;
    	}
    }
    int main()
    {
        
    	/*
    	在lhf::string to_string(int value)函数中可以看到，这里只能使用传值返回，
    	传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
    	*/
    	lhf::string ret1 = lhf::to_string(1234);
    	lhf::string ret2 = lhf::to_string(-1234);
    	return 0;
    }

![512d1f3d8e394f7a9bec91f76ad0da11.png][]  
**to\_string的返回值是一个右值，用这个右值构造ret2，如果没有移动构造，就会匹配调用string的拷贝构造，因为const左值引用可以调用右值，实现深拷贝。**

**右值引用和移动语义解决左值引用的短板：**

在lhf::string中增加移动构造，**移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己**。

// 移动构造
    string(string&& s)
    	:_str(nullptr)
    	, _size(0)
    	, _capacity(0)
    {
        
    	cout << "string(string&& s) -- 移动语义" << endl;
    	swap(s);
    }
    
    int main()
    {
        
    	lhf::string ret1 = lhf::to_string(1234);
    	lhf::string ret2 = lhf::to_string(-1234);
    	return 0;
    }

**再运行上面lhf::to\_string的两个调用，我们会发现，这里没有调用深拷贝的拷贝构造，而是调用了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了。**  
![df6c422c442f42ecba8155ad16fe9c3f.png][]  
![d31b6b54f1f14bdabf25364b1d1b35cb.png][]  
**to\_string的返回值是一个右值，用这个右值构造ret2，如果既有移动构造又有拷贝构造，因为编译器会选择最匹配的参数调用。那么这里就会调用移动构造，是一个移动语义。**

**除了移动构造，还有移动赋值：**

在lhf::string类中增加移动赋值函数，再去调用lhf::to\_string(1234)，不过这次是将lhf::to\_string(1234)返回的右值对象赋值给ret1对象，这时调用的是移动构造。

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

**运行结果：**  
![e7bb6967a340476f9f6c61a2fa81cbad.png][]  
这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是**用一个已经存在的对象接收，编译器就没办法优化了**。**lhf::to\_string函数中会先用str生成构造生成一个临时对象，但是我们可以看到，编译器很聪明的在这里把str识别成了右值**，调用了移动构造。**然后在把这个临时对象做为lhf::to\_string函数调用的返回值赋值给ret1，这里调用的移动赋值**。

**在C++11中，STL中的容器都是增加了移动构造和移动赋值：**  
例如：  
![f099270cfd3d42c180801cb622340dc8.png][]

![59a26eec0e6c43e7ba13c933da3c97f0.png][]

## 4. 右值引用引用左值 ##

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当**需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值**。  
在C++11中，标准库在中提供了一个有用的函数std::move，**std::move并不能移动任何东西，它唯一的功能是将一个左值强制转化为右值引用，继而可以通过右值引用使用该值**，以用于移动语义。从实现上讲，std::move基本等同于一个类型转换：static\_cast<T&&>(lvalue)。

std::move函数可以以非常简单的方式将左值引用转换为右值引用：

*  C++ 标准库使用比如vector::push\_back 等这类函数时,会对参数的对象进行复制,连数据也会复制.这就会造成对象内存的额外创建, 本来原意是想把参数push\_back进去就行了，通过std::move，可以避免不必要的拷贝操作。
 *  std::move是将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存的搬迁或者内存拷贝所以可以提高利用效率，改善性能.。
 *  对指针类型的标准库对象并不需要这么做。

例如：

#include <iostream>
    #include <utility>
    #include <vector>
    #include <string>
    int main()
    {
        
        std::string str = "Hello";
        std::vector<std::string> v;
        //调用常规的拷贝构造函数，新建字符数组，拷贝数据
        v.push_back(str);
        std::cout << "After copy, str is \"" << str << "\"\n";
        //调用移动构造函数，掏空str，掏空后，最好不要使用str
        v.push_back(std::move(str));
        std::cout << "After move, str is \"" << str << "\"\n";
        std::cout << "The contents of the vector are \"" << v[0] << "\", \"" << v[1] << "\"\n";
    }

执行结果：  
![683d2ef9d7114a91b907046fb3176682.png][]

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

![9662171c45b14949b3fa3727546e0646.png][]

![9c95239192ac4d1d80ed6f3f3b90c1de.png][]

例如：

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

运行结果：  
![c2b0af1f7ca1427b99b47efd61c74e30.png][]  
![899a6b9a984d4e95b56be5ef729306e5.png][]

## 5. 完美转发 ##

模板中的&& 万能引用

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

![2bddcfdb05384966994c469d36e91123.png][]

> 由结果可知上面的右值经过&& 万能引用后，全部退化成了左值。

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

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

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

![55c5e2fa2fb24daea65cdbdf3473e77f.png][]

# 六、类的新功能 #

## 1. 默认成员函数 ##

原来C++类中，有6个默认成员函数：

> 1.  构造函数
> 2.  析构函数
> 3.  拷贝构造函数
> 4.  拷贝赋值重载
> 5.  取地址重载
> 6.  const 取地址重载

默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：**移动构造函数和移动赋值运算符重载**。针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

*  如果没有自己实现移动构造函数，且**没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个**。那么编译器会自动生成一个默认移动构造。**默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造**。
 *  如果没有自己实现移动赋值重载函数，且**没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个**，那么编译器会自动生成一个默认移动赋值。**默认生成的移动赋值函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值**。(默认移动赋值跟上面移动构造完全类似)
 *  如果自己提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

## 2. 强制生成默认函数的关键字default ##

C++11可以让我们更好的控制要使用的默认函数。假设要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。

class Person
    {
        
    public:
    	Person(const char* name = "", int age = 0)
    	:_name(name)
    	, _age(age)
    	{
        }
    	Person(const Person& p)
    	:_name(p._name)
    	,_age(p._age)
    	{
        }
    	//强制默认生成移动拷贝构造
    	Person(Person&& p) = default;
    private:
    	bit::string _name;
    	int _age;
    };
    int main()
    {
        
    	Person s1;
    	Person s2 = s1;
    	Person s3 = std::move(s1);
    	return 0;
    }

## 3. 禁止生成默认函数的关键字delete ##

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁，这样只要其他人想要调用就会报错。**在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数**。

class Person
    {
        
    public:
    	Person(const char* name = "", int age = 0)
    	:_name(name)
    	, _age(age)
    	{
        }
    	Person(const Person& p) = delete;
    private:
    	bit::string _name;
    	int _age;
    };
    int main()
    {
        
    	Person s1;
    	Person s2 = s1;
    	Person s3 = std::move(s1);
    	return 0;
    }

# 七、Lambda表达式 #

见文章[【Lambda表达式的用法与原理】][Lambda]

# 八、智能指针 #

# 九、包装器 #

## 1. 包装器的概念 ##

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。它是一种通用、多态的函数封装，它的实例可以对任何可以调用的目标实体进 行存储、复制和调用操作，它也是对 C++ 中现有的可调用实体的一种类型安全的包裹（相对来说，函数 指针的调用不是类型安全的），换句话说，就是函数的容器。当我们有了函数的容器之后便能够更加方便 的将函数、函数指针作为对象进行处理。

std::function在头文件<functional>
    // 类模板原型如下
    template <class T> function;   // undefined
    template <class Ret, class... Args>
    class function<Ret(Args...)>;
    
    /*
    模板参数说明：
    Ret: 被调用函数的返回类型
    Args…：被调用函数的形参
    */

## 2. 为什么要有包装器 ##

例如：  
有一句代码 ret = func(x);  
上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！为什么呢？我们继续往下看。

template<class F, class T>
    T useF(F f, T x)
    {
        
    	static int count = 0;
    	cout << "count:" << ++count << endl;
    	cout << "count:" << &count << endl;
    	return f(x);
    }
    double f(double i)
    {
        
    	return i / 2;
    }
    struct Functor
    {
        
    	double operator()(double d)
    	{
        
    		return d / 3;
    	}
    };
    
    int main()
    {
        
    	// 函数名
    	cout << useF(f, 11.11) << endl;
    	// 函数对象
    	cout << useF(Functor(), 11.11) << endl;
    	// lamber表达式
    	cout << useF([](double d)->double {
         return d / 4; }, 11.11) << endl;
    	return 0;
    }

通过上面的程序验证，我们会发现useF函数模板实例化了三份。使用包装器可以很好的解决上面的问题。

// 使用方法如下：
    #include <functional>
    int f(int a, int b)
    {
        
    	return a + b;
    }
    
    struct Functor
    {
        
    public:
    	int operator() (int a, int b)
    	{
        
    		return a + b;
    	}
    };
    
    class Plus
    {
        
    public:
    	static int plusi(int a, int b)
    	{
        
    		return a + b;
    	}
    	double plusd(double a, double b)
    	{
        
    		return a + b;
    	}
    };
    
    int main()
    {
        
    	// 函数名(函数指针)
    	std::function<int(int, int)> func1 = f;
    	cout << func1(1, 2) << endl;
    
    	// 函数对象
    	std::function<int(int, int)> func2 = Functor();
    	cout << func2(1, 2) << endl;
    
    	// lamber表达式
    	std::function<int(int, int)> func3 = [](const int a, const int b)
    	{
        return a + b; };
    	cout << func3(1, 2) << endl;
    
    	// 类的成员函数
    	std::function<int(int, int)> func4 = &Plus::plusi;
    	//静态成员函数可以不加&符号
    	std::function<int(int, int)> func4 = Plus::plusi;
    	cout << func4(1, 2) << endl;
    
    	std::function<double(Plus, double, double)> func5 = &Plus::plusd;
    	cout << func5(Plus(), 1.1, 2.2) << endl;
    	return 0;
    }

利用包装器，解决模板的效率低下，实例化多份的问题。

#include <functional>
    template<class F, class T>
    T useF(F f, T x)
    {
        
    	static int count = 0;
    	cout << "count:" << ++count << endl;
    	cout << "count:" << &count << endl;
    	return f(x);
    }
    double f(double i)
    {
        
    	return i / 2;
    }
    struct Functor
    {
        
    	double operator()(double d)
    	{
        
    		return d / 3;
    	}
    };
    int main()
    {
        
    	// 函数名
    	std::function<double(double)> func1 = f;
    	cout << useF(func1, 11.11) << endl;
    	
    	// 函数对象
    	std::function<double(double)> func2 = Functor();
    	cout << useF(func2, 11.11) << endl;
    	
    	// lamber表达式
    	std::function<double(double)> func3 = [](double d)->double {
         return d /4; };
    	cout << useF(func3, 11.11) << endl;
    
    	return 0;
    }

利用包装器解决[【逆波兰表达式】][Link 1]

根据逆波兰表示法，求表达式的值。

> 有效的算符包括 +、-、\*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。  
> 【注意 】
> 
>  *  两个整数之间的除法只保留整数部分。
>  *  可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

代码如下：

class Solution {
        
    public:
        int evalRPN(vector<string>& tokens) {
        
            stack<long long> s;
    
            map<string, function<long long(long long, long long)> > opFuncMap = 
            {
        
                {
        "+", [](long long x, long long y){
        return x + y;}},
                {
        "-", [](long long x, long long y){
        return x - y;}},
                {
        "*", [](long long x, long long y){
        return x * y;}},
                {
        "/", [](long long x, long long y){
        return x / y;}}
            };
    
            for(auto& str : tokens)
            {
        
                if(opFuncMap.count(str)) //操作符
                {
        
                    long long right = s.top();
                    s.pop();
                    long long left = s.top();
                    s.pop();
    
                    s.push(opFuncMap[str](left, right));
                }
                else // 操作数
                {
        
                    s.push(stoll(str));
                }
            }
    
            return s.top();
        }
    };

## 3. bind ##

std::bind函数定义在头文件中，是一个函数模板，它**就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表**。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

// 原型如下：
    template <class Fn, class... Args>
    /* unspecified */ 
    bind (Fn&& fn, Args&&... args);
    
    // with return type (2)
    template <class Ret, class Fn, class... Args>
    /* unspecified */
     bind (Fn&& fn, Args&&... args);

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。  
调用bind的一般形式：

> auto newCallable = bind(callable,arg\_list);

其中，newCallable本身是一个可调用对象，arg\_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg\_list中的参数。

arg\_list中的参数可能包含形如\_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：\_1为newCallable的第一个参数，\_2为第二个参数，以此类推。

// 使用举例
    #include <functional>
    int Plus(int a, int b)
    {
        
    	return a + b;
    }
    class Sub
    {
        
    public:
    	int sub(int a, int b)
    	{
        
    		return a - b;
    	}
    };
    int main()
    {
        
    	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
    	std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
    	//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
    	//func2的类型为 function<void(int, int, int)> 与func1类型一样
    
    	//表示绑定函数 plus 的第一，二为： 1， 2
    	auto func2 = std::bind(Plus, 1, 2);
    	cout << func1(1, 2) << endl;
    	cout << func2() << endl;
    
    	Sub s;
    	// 绑定成员函数
    	std::function<int(int, int)> func3 = std::bind(&Sub::sub, s, placeholders::_1, placeholders::_2);
    	// 参数调换顺序
    
    	std::function<int(int, int)> func4 = std::bind(&Sub::sub, s, placeholders::_2, placeholders::_1);
    	cout << func3(1, 2) << endl; // -1
    	cout << func4(1, 2) << endl; // 1
    	return 0;
    }

[std_initializer_list]: https://cplusplus.com/reference/initializer_list/initializer_list/
[c3c9c2131792489689453490c1f9a114.png]: https://img-blog.csdnimg.cn/c3c9c2131792489689453490c1f9a114.png
[6fa72416e1fb45109ea50588370b17c7.png]: https://img-blog.csdnimg.cn/6fa72416e1fb45109ea50588370b17c7.png
[3ec4c3064ba14abfadd6678cee12117f.png]: https://img-blog.csdnimg.cn/3ec4c3064ba14abfadd6678cee12117f.png
[C_ unordered_map_unordered_set]: https://blog.csdn.net/qq_61635026/article/details/126857258?spm=1001.2014.3001.5501
[unordered]: https://blog.csdn.net/qq_61635026/article/details/126899076?spm=1001.2014.3001.5501
[std_vector_emplace_back]: https://cplusplus.com/reference/vector/vector/emplace_back/
[std_vector_push_back]: https://cplusplus.com/reference/vector/vector/push_back/
[std_map_insert]: https://cplusplus.com/reference/map/map/insert/
[std_map_emplace]: https://cplusplus.com/reference/map/map/emplace/
[2cf4400e8c5b4816b7d59da2c4c186a1.png]: https://img-blog.csdnimg.cn/2cf4400e8c5b4816b7d59da2c4c186a1.png
[512d1f3d8e394f7a9bec91f76ad0da11.png]: https://img-blog.csdnimg.cn/512d1f3d8e394f7a9bec91f76ad0da11.png
[df6c422c442f42ecba8155ad16fe9c3f.png]: https://img-blog.csdnimg.cn/df6c422c442f42ecba8155ad16fe9c3f.png
[d31b6b54f1f14bdabf25364b1d1b35cb.png]: https://img-blog.csdnimg.cn/d31b6b54f1f14bdabf25364b1d1b35cb.png
[e7bb6967a340476f9f6c61a2fa81cbad.png]: https://img-blog.csdnimg.cn/e7bb6967a340476f9f6c61a2fa81cbad.png
[f099270cfd3d42c180801cb622340dc8.png]: https://img-blog.csdnimg.cn/f099270cfd3d42c180801cb622340dc8.png
[59a26eec0e6c43e7ba13c933da3c97f0.png]: https://img-blog.csdnimg.cn/59a26eec0e6c43e7ba13c933da3c97f0.png
[683d2ef9d7114a91b907046fb3176682.png]: https://img-blog.csdnimg.cn/683d2ef9d7114a91b907046fb3176682.png
[9662171c45b14949b3fa3727546e0646.png]: https://img-blog.csdnimg.cn/9662171c45b14949b3fa3727546e0646.png
[9c95239192ac4d1d80ed6f3f3b90c1de.png]: https://img-blog.csdnimg.cn/9c95239192ac4d1d80ed6f3f3b90c1de.png
[c2b0af1f7ca1427b99b47efd61c74e30.png]: https://img-blog.csdnimg.cn/c2b0af1f7ca1427b99b47efd61c74e30.png
[899a6b9a984d4e95b56be5ef729306e5.png]: https://img-blog.csdnimg.cn/899a6b9a984d4e95b56be5ef729306e5.png
[2bddcfdb05384966994c469d36e91123.png]: https://img-blog.csdnimg.cn/2bddcfdb05384966994c469d36e91123.png
[55c5e2fa2fb24daea65cdbdf3473e77f.png]: https://img-blog.csdnimg.cn/55c5e2fa2fb24daea65cdbdf3473e77f.png
[Lambda]: https://blog.csdn.net/qq_61635026/article/details/127143053?spm=1001.2014.3001.5501
[Link 1]: https://leetcode.cn/problems/evaluate-reverse-polish-notation/