C++11

C++11常用语法

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能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。

统一的列表初始化

C++98{}中的列表初始化

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

struct Point
{
    
	int _x;
	int _y;
};


int main()
{
    
	int arr1[] = {
     1, 2, 3, 4, 5 };
	int arr2[] = {
     0 };

	Point p1 = {
     1, 2 }; 
	return 0;
}

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

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

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

内置类型的列表初始化

int main()
{
    
	//内置类型变量
	int a = 1;
	int b = {
     2 };
	int c{
     3 };
	
	int arr1[]{
    1, 2, 3, 4, 5};
	int arr2[5]{
    0};

	//动态数组，在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;
}

注意： 列表初始化可以在{}之前使用等号，其效果与不使用=没有什么区别，但是为了代码的可读性建议加上=。

自定义类型的列表初始化

1. 标准库支持单个对象的列表初始化

   struct Point
   {
         
   	int _x;
   	int _y;
   
   	Point(int x, int y)
   		:_x(x)
   		, _y(y)
   	{
         
   		cout << "Point(int x, int y)" << endl;
   	}
   };
   
   
   int main()
   {
         
   	//C++11
   	Point p1(1, 2);
   	//多参数构造函数，支持隐式类型转换
   	Point p2 = {
          1, 2 };
   	Point p3{
          1, 2 };//建议把等号写出来
   
   	Point* ptr1 = new Point[2]{
         {
          1, 1 }, {
          2, 2 }};
   
   	return 0;
   }
   

2. 多个对象的列表初始化

   多个对象想要支持列表初始化，需要给该类(模板类) 添加一个带有initializer_list类型参数的构造函数即可

   

   注意：initializer_list是系统自定义的类模板， C++11对STL中的不少容器都增加了initializer_list类型参数的构造函数，这样去初始化容器对象就会变得更加方便。下面我们来看几个支持initializer_list类型参数的构造函数的容器：

   • vector

   

   • string

     

   • list

   

   • map

   

   下面我们来模拟一个initializer_list类型作为参数的构造函数和赋值重载

   template<class T>
   class Vector
   {
         
   public:
   	Vector(initializer_list<T> l)
   		:_size(0)
   		,_capacity(l.size())
   	{
         
   		_a = new T[_capacity];
   		for (auto e : l)
   		{
         
   			_a[_size++] = e;
   		}
   	}
   	Vector<T>& operator=(initializer_list<T> l)
   	{
         
   		delete _a;
   		_size = 0;
   		_capacity = l.size();
   		_a = new T[_capacity];
   		for (auto e : l)
   		{
         
   			_a[_size++] = e;
   		}
   
   		return *this;
   	}
   private:
   	T* _a;
   	size_t _size;
   	size_t _capacity;
   };
   
   int main()
   {
         
   	Vector<int> v1 = {
          1,2,3,4,5 };
   	Vector<int> v2 = {
          3,5,7,9,10 };
   	v2 = {
          1,2,3 };
   	
   	return 0;
   }
   
   

变量类型推导

为什么需要类型推导

在定义变量时，必须先给出变量的实际类型，编译器才允许定义，但有些情况下可能不知道需要实际类型该怎么给，或者类型写起来特别复杂，比如;

int main()
{
    
	short a = 32760;
	short b = 32760;

	//c如果给出short，会造成数据丢失，如果能够让编译器根据a+b的结果推导c的实际类型，就不会存在问题
	short c = a + b;

	std::map<std::string, std::string>m{
     {
     "sort", "排序" }, {
     "apple", "苹果" }, {
     "list", "列表" } };
	//使用迭代器遍历容器，迭代器类型太繁琐
	std::map<std::string, std::string>::iterator it = m.begin();
	while (it != m.end())
	{
    
		cout << it->first << " " << it->second << endl;
		++it;
	}

	return 0;
}

在C++11中，可以使用auto来根据变量初始化表达式类型去推导变量的实际类型，可以给程序的书写提供许多方便，将程序中的c与it的类型换成auto，程序可以通过编译，而且更加的简洁。

	//使用迭代器遍历容器，迭代器类型太繁琐
	//std::map<std::string, std::string>::iterator it = m.begin();
	auto it = m.begin();
	while (it != m.end())
	{
    
		cout << it->first << " " << it->second << endl;
		++it;
	}

decltype类型推导

auto使用的前提是：必须要对auto声明的类型进行初始化，否则编译器无法推导出auto的实际类型。 但有时候可能需要根据表达式运行完成之后结果的类型进行推导，因为编译期间，代码不会允许，此时auto也就无能为力

decltype

decltype是根据表达式的实际类型推演出定义变量时所用的类型，比如：

1. 推演表达式类型作为变量的定义类型

   int main()
   {
         
   	int a = 10;
   	int b = 20;
   
   	//用decltype推演a+b的实际类型，作为定义c的类型
   	decltype(a + b) c;
   	cout << typeid(c).name() << endl;
   
   	decltype(&a) p;//p的类型是int*
   	cout << typeid(p).name() << endl;
   
   
   	return 0;
   
   }
   

   

2. 推演函数返回值的类型

int Add(int x, int y)
{
    
	return x + y;
}


int main()
{
    
	 如果没有带参数，推导函数的类型
	cout << typeid(decltype(Add)).name() << endl;

	// 如果带参数列表，推导的是函数返回值的类型,注意：此处只是推演，不会执行函数
	cout << typeid(decltype(Add(1,2))).name() << endl;


	return 0;
}

final与override

final

• final修饰一个类的时候，表示该类不能被继承

  //被final修饰的类我们一般叫做最终类，无法被继承
  class A final
  {
        
  private:
  	int _a;
  };
  
  //无法继承
  class B :public A
  {
        
  	//...
  };
  

  

• final修饰虚函数时，这个虚函数不能被重写

  class A
  {
        
  public:
  	virtual void fun()final
  	{
        
  		cout << "A::fun()" << endl;
  	}
  private:
  	int _a;
  };
  
  class B : public A
  {
        
  public:
  	//这个虚函数在父类中用了final修饰，表示最后一个虚函数，无法重写
  	virtual void fun()
  	{
        
  		cout << "B::fun()" << endl;
  	}
  };
  
  

override

override用来检查派生类是否重写了基类某个虚函数，如果没有重写编译报错

完成了重写：

class A
{
    
public:
	virtual void fun()
	{
    
		cout << "A::fun()" << endl;
	}
private:
	int _a;
};

class B : public A
{
    
public:
	//override：检查派生类虚函数是否重写了基类中的某个虚函数，如果没有重写就编译报错
	virtual void fun()override
	{
    
		cout << "B::fun()" << endl;
	}
};

未完成重写：

class A
{
    
public:
	virtual void fun()
	{
    
		cout << "A::fun()" << endl;
	}
private:
	int _a;
};

class B : public A
{
    
public:
	//override：检查派生类虚函数是否重写了基类中的某个虚函数，如果没有重写就编译报错
	virtual void fun(int )override
	{
    
		cout << "B::fun()" << endl;
	}
};

默认成员函数控制

在C++中对于 空类编译器会生成一些默认的成员函数 ，比如： 构造函数、拷贝构造函数、运算符重载、析构函数和&和const&的重载、移动构造、移动拷贝构造等函数。如果在类中显式定义了，编译器将不会重新生成默认版本。 有时候这样的规则可能被忘记，最常见的是声明了带参数的构造函数，必要时则需要定义不带参数的版本以实例化无参的对象。而且 有时编译器会生成，有时又不生成，容易造成混乱，于是C++11让程序员可以控制是否需要编译器生成。

显示缺省函数

在C++11中，可以在默认函数定义或者声明时加上=default，从而显示的指示编译器生成该函数的默认版本，用=default修饰的函数称为显示缺省函数

class A
{
    
public:
	A(int a)
		:_a(a)
	{
    }
private:
	int _a;
};

int main()
{
    
	A a;
	return 0;
}

用default显示的去修饰构造函数，就会让编译器生成默认的构造函数

class A
{
    
public:
	A(int a)
		:_a(a)
	{
    }
	//显示缺省构造函数，由编译器生产
	A() = default;
private:
	int _a;
};

int main()
{
    
	A a;
	return 0;
}

删除默认函数

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

class A
{
    
public:
	A(int a)
		:_a(a)
	{
    }
	//禁止编译器生成默认的拷贝构造和赋值重载
	A(const A&) = delete;
	A& operator=(const A&) = delete;

private:
	int _a;
};

int main()
{
    
	A a1(10);
	//编译失败，因为该类没有拷贝构造函数
	A a2(a1);
	//编译失败，因为该类没有赋值运算符重载
	A a3(20);
	a3 = a2;
	return 0;
}

注意： 避免删除函数与explicit一起使用

右值引用和移动语义

我们在刚开始学C++的时候就学过引用，只不过我们当时学的是左值引用，C++11新增了右值引用的语法特性，无论是左值引用还是右值引用，都是在给对象取别名(黑旋风——李逵)，引用变量与引用实体公用同一块内存空间。

什么是左值？什么是左值引用？

左值是一个表示数据的表达式（如变量名火解引用的指针），我们可以获取它的地址或者可以对它进行赋值，左值可以出现在赋值符号的左边，右值不能出现在赋值符号的左边。在定义时用const修饰后的左值，不能给它赋值，但是可以取它的地址。左值引用就是给左值取别名。

 //可以取地址的对象，就是左值
int main()
{
    
	int a = 10;
	int& r1 = a;
	int* p = &a;
	int& r2 = *p;

	const int b = 10;
	const int& r3 = b;

	return 0;
}

总结：

• 左值都可以取地址
• 左值一般情况下可以进行修改，但是被const修饰的左值不能被修改

什么是右值？什么是右值引用？

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，传值返回函数的返回值（这个不能是左值引用返回）等等，右值可以出现在赋值符号的右边，但是不能出现在赋值符号的左边，右值不能取地址。右值引用就是给右值取别名

// 不能取地址的对象，就是右值
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);

	return 0;
}

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

左值引用与右值引用比较

左值引用总结：

• 左值引用只能引用左值，不能直接引用右值
• const左值引用既可以引用左值，也可以引用右值（const 通吃）

int main()
{
    
	//左值引用只能引用左值，不能直接引用右值
	int a = 10;
	int& ra1 = a;
	//int& ra2 = 10;//编译报错，因为10是右值

	//const左值既可以引用左值，也可以引用右值，简称const通吃
	const int& ra3 = 10;
	const int& ra4 = a;

	return 0;
}

右值引用总结：

• 右值引用只能引用右值，不能直接引用左值
• 右值引用可以引用move以后的左值

int main()
{
    
	int a = 10;
	int b = 20;
	//右值引用只能引用右值，不能直接引用左值
	//int&& r1 = a;
	int&& r2 = 10;

	//右值引用可以引用move后的左值
	int&& r3 = std::move(b);
	return 0;
}

注意： move——当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于算法头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

右值引用使用场景和意义

左值引用既可以引用左值，使用const修饰后还可以引用右值，那为什么C++11还要提出右值引用？因为左值引用它还存在一些短板

namespace mlf
{
    
	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)
			, _size(0)
			, _capacity(0)
		{
    
			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;
		// swap(s);

		// return *this;
		//}

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

			return *this;
		}

		~string()
		{
    
			//cout << "~string()" << endl;

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

		string operator+(char ch)
		{
    
			string tmp(*this);
			push_back(ch);

			return tmp;
		}

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

	mlf::string to_string(int value)
	{
    
		mlf::string str;
		while (value)
		{
    
			int val = value % 10;
			str += ('0' + val);
			value /= 10;
		}
		reverse(str.begin(), str.end());

		return str;
	}
}


//场景1
//左值引用做参数，基本完美的解决所有问题
void func1(mlf::string s)
{
    }


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


//场景2
//左值引用做返回值，只能解决部分问题
// string& operator+=(char ch) 解决了
// string operator+(char ch) 没有解决


int main()
{
    
	mlf::string str("hello world");
	//左值引用做参数，基本完美的解决所有问题
	func1(str);
	func2(str);

	//返回时这个对象还在，可以使用左值
	str += '!';
	//不能使用左值引用返回，左值引用做返回值时只能解决部分问题
	str + '!';
    //不能使用左值引用返回，这个就是左值引用的一个短板
	//函数返回对象出了作用域就不在了，因此不能用左值引用返回（因为返回的是本身地址，栈帧已销毁）
	//所以会存在拷贝问题
    mlf::string ret = mlf::to_string(1234);

	return 0;
}

下面我们一起来分析一下左值引用的短板以及如何使用右值引用来解决的

to_string是一个传值返回的函数，它最后返回的并不是str，返回的是str的拷贝，str会先拷贝构造一个临时对象（这里会发生一次深拷贝），然后再将临时对象拷贝构造给ret（这里会再发送一次拷贝构造），连续的两次构造会被编译器优化成一次，因为我们这里只会看到一次拷贝构造

下面来分析一下上面传值返回的问题：

• 传值返回的to_string函数正常返回时，需要用str构造一个临时对象，临时对象和str中的内容完全相同，出来函数作用域后，str就被销毁掉了，这个过程经历了——刚申请一段空间，又是一段相同大小的空间，这对于资源无疑是一种很大的浪费

那么针对上面传值返回的问题，我们如何通过右值引用来解决呢？

我们可以通过在string类里面提供一个移动构造的成员函数来解决上面的问题

		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
    
			cout << "string(string&& s) -- 资源转移" << endl;

			this->swap(s);
		}

注意：右值又分为纯右值和将亡值

• 纯右值：10、a+b
• 将亡值：函数返回的临时对象、匿名对象

除了移动构造外，我们还可以增加移动赋值在某些场景下来提高效率

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

			return *this;
		}

下面我们来看一下移动赋值的使用场景：

int main()
{
    
	mlf::string ret;
	ret = mlf::to_string(1234);

	return 0;
}

可以看到当代码里面如果没有移动赋值时，我们这里就是一次移动构造加上两次深拷贝，大家可能会有点疑问为什么会有两次深拷贝呢？因为我们的赋值重载是现代写法，里面会调用拷贝构造，因此就会出现两次深拷贝。

下面我们来对这段代码进行分析一下

• to_string函数它是传值返回的，我们知道传值返回的函数的返回值是一个将亡值，因为我们这里有移动构造，那么就会将这个返回的str识别成将亡值（右值），然后将它的资源转移到临时对象身上，再调用赋值重载将这个临时对象的值赋给ret，调用赋值重载需要两次深拷贝（现代写法复用了拷贝构造），这样的代价是很大的。

那我们如何通过移动赋值来解决上面的问题呢？

当我们将str的这个将亡值的资源通过移动构造转移到临时对象身上之后，我们可以将临时对象的资源转移到ret身上，也就不需要再去调用赋值运算符重载，而是调用移动赋值，这样就会减少深拷贝，从而由一次移动构造+两次深拷贝变成了一次移动构造+一次移动赋值

下面我们再来看一下右值引用的一些使用场景

int main()
{
    
	list<mlf::string>lt;
	mlf::string s("111111");
	lt.push_back(s);
	cout << endl;

	lt.push_back("222222");
	cout << endl;

	lt.push_back(mlf::to_string(333333));

	return 0;
}

总结：

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

完美转发

完美转发是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。

void Func(int x)
{
    
	//...
}


template<typename T>
void PerfectForward(T t)
{
    
	Func(t);
}

PerfectForward为转发的模板函数，Func为实际目标函数， 但是上述转发还不算完美， 完美转发是目标函数总希望将参数按照传递给转发函数的实际类型转给目标函数，而不产生额外的开销， 就好像转发者不存在一样。

所谓完美： 函数模板在向其他函数传递自身形参时，如果相应实参是左值，它就应该被转发为左值；如果相应实参是右值，它就应该被转发为右值。 这样做是为了保留在其他函数针对转发而来的参数的左右值属性进行不同处理（比如参数为左值时实施拷贝语义；参数为右值时实施移动语义）

我们先来了解一下万能引用吧

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

下面我们先来看一段代码

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

运行结果：

看到这个运行结果之后大家心里面可能会有点疑惑：你刚刚上面自己说万能引用既可以接受左值也可以接受右值，那为什么这里万能引用接受了右值之后再去调用Fun函数，调用的却是左值引用或者const左值引用的Fun函数呢？

不知道大家是否还记得我们在前面说过右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址。 因此右值引用的对象，再作为实参传递时它的属性会退化成左值，因此只能匹配左值引用的Fun函数

那我们如何解决这个问题呢？

我们可以采用完美转发来解决

下面我们来看一下完美转发的代码

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(std::forward<T>(t));
}

int main()
{
    
    //Fun(t);
    //完美转发
	PerfectForward(10);           // 右值

	int a;
	PerfectForward(a);            // 左值
	PerfectForward(std::move(a)); // 右值

	const int b = 8;
	PerfectForward(b);		      // const 左值
	PerfectForward(std::move(b)); // const 右值

	return 0;
}

运行结果：

可以看到我们使用了完美转发之后，左值就匹配左值引用的Fun函数，右值就匹配右值引用的Fun函数，达到了我们想要的结果。

新的类功能

默认成员函数

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

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

最重要的是前4个，后两个用处不大，默认成员函数就是我们不写编译器会生成一个默认的。

C++11新增了两个：移动构造和移动赋值运算符重载

针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

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

下面我们用自己简单模拟实现的string在VS2019环境下进行演示。我们用Person类有析构函数和没有析构函数，两种情况下，使用右值构造一个对象、使用右值对象给另一个对象进行赋值，看看会调用哪个函数。

有析构函数：

namespace mlf
{
    
	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)
			, _size(0)
			, _capacity(0)
		{
    
			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;
			swap(s);

			return *this;
		}

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

			return *this;
		}

		~string()
		{
    
			//cout << "~string()" << endl;

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

		string operator+(char ch)
		{
    
			string tmp(*this);
			push_back(ch);

			return tmp;
		}

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

	mlf::string to_string(int value)
	{
    
		mlf::string str;
		while (value)
		{
    
			int val = value % 10;
			str += ('0' + val);
			value /= 10;
		}
		reverse(str.begin(), str.end());

		return str;
	}
}


class Person
{
    
public:
	Person(const char* name = "张三", int age = 0)
		:_name(name)
		, _age(age)
	{
    }
	~Person()
	{
    }
private:
	mlf::string _name;
	int _age;
};

int main()
{
    
	Person s1;
	Person s2;

	Person s3 = std::move(s1);
	s2 = std::move(s3);
	return 0;
}

运行结果：

没有析构函数：

class Person
{
    
public:
	Person(const char* name = "张三", int age = 0)
		:_name(name)
		, _age(age)
	{
    }
	/*~Person() {}*/
private:
	mlf::string _name;
	int _age;
};

int main()
{
    
	Person s1;
	Person s2;

	Person s3 = std::move(s1);
	s2 = std::move(s3);
	return 0;
}

运行结果：

通过上面的运行结果我们可以看到，编译器生成默认的移动构造和移动赋值的条件还是很苛刻的。

可变模板参数

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模板和函数模板中只能含固定数量的模板参数，可变模板参数无疑是一个巨大的改进。

下面就是一个基本可变参数的函数模板

//Args是一个模板参数包，args是一个函数形参参数包
//声明一个参数包Args...args,这个参数包中可以包含0到任意个模板参数
template<class...Args>
void ShowList(Args... args)
{
    }

上面的参数Args前面有省略号，所以它就是一个可变模板参数，我们把带省略号的参数称为参数包，它里面包含了0到N（N>=0）个模板参数。我们无法直接获取参数包Args中的每个参数，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模板参数的一个主要特点，也是最大的难点，即如何展开可变模板参数。

下面我们先来解决第一个问题：如何获取参数包的个数呢？

//可变参数，你传int，char，还是自定义类型都会自动给你推导
//可以包含0 - 任意个参数
template<class ...Args>
void ShowList(Args... args)
{
    
	cout << sizeof...(args) << endl;//计算参数包的个数
}
int main()
{
    
	ShowList(1);
	ShowList(1, 'a');
	ShowList(1, 'z', string("sort"));
	ShowList(1, 'a', 'A',string("sort"));
	return 0;
}

运行结果：

下面我们介绍两种方法来展开可变模板参数：

• 递归函数方式展开参数包

  递归调用ShowList，当参数包中的参数个数为0时，调用递归终止函数，args中第一个参数作为value传参，参数包中剩下的参数作为新的参数包传参，如此我们便拿到了参数包里面的所有参数

  //递归终止函数
  template<class T>
  void ShowList(const T& t)
  {
        
  	cout << t << endl;
  }
  
  //解析并打印参数包中每个参数的类型及值
  template<class T,class ...Args>
  void ShowList(T val, Args...args)
  {
        
  	cout << typeid(val).name() << ":" << val << endl;
  	递归调用
  	ShowList(args...);
  }
  
  
  int main()
  {
        
  	ShowList(1);
  	ShowList(1, 'A');
  	ShowList(1, 'A', std::string("sort"));
  	return 0;
  }
  

  运行结果：

  

  上面这种写法有些人可能觉得有点复杂了，因为每一次展开模板参数，我们都需要用第一个参数val去推，那有没有什么办法不用第一个参数去推并且也能展开模板参数呢，下面我们来介绍第二种方法

• 逗号表达式展开参数包

  如果一个参数包中的参数都是同一类型，那么可以使用该参数包对数组进行列表初始化，参数包会进行展开，如何对数组进行初始化。

  template<class...Args>
  void ShowList(Args...args)
  {
        
  	int arr[] = {
         args... };
  	cout << endl;
  }
  
  int main()
  {
        
  	ShowList(1, 2, 3);
  	return 0;
  }
  

  

  那如果参数包里面的参数不是同一类型的我们应该如何去做呢？我们可以在使用列表初始化数组时，展开参数包的特性，再与一个逗号表达式结合使用，既展开了参数包又对数组进行了初始化。

  template<class T>
  void PrintArg(T val)
  {
        
  	cout << typeid(T).name() << ":" << val << endl;
  }
  
  
  //展开函数
  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;
  }
  

  

学习了可变模板参数参数与右值引用之后，下面我们再来了解一下STL容器里面的emplace_back系列接口，并且对比一下push_back接口

注意：这里的&&不是右值引用而是万能引用，如果实参是左值，那么参数包的形参就是左值引用，如果实参是右值，那么参数包的形参就是右值引用。

下面我们先来看一下push_back与emplace_back 的用法上面有没有上面区别

int main()
{
    
	std::list< std::pair<int, char> > mylist;
	mylist.push_back(make_pair(1, 'A'));
	mylist.push_back({
     1, 'A' });
	mylist.emplace_back(make_pair(1, 'A'));
	mylist.emplace_back(1, 'A');

	for (auto e : mylist)
		cout << e.first << ":" << e.second << endl;
}

可以看到push_back与emplace_back在用法上其实没什么区别，可以说基本上用法是一样的。

只不过emplace_back支持可变参数包，然后调用定位new，使用参数包对空间进行初始化，即支持下面这种

mylist.emplace_back(1, 'A');

push_back虽然不支持这种方式初始化，但是它可以使用初始化列表来进行类似的操作，但是emplace_back不能使用初始化列表来进行这种操作，因为push_back知道传进来的参数的类型。但是emplace_back接受的是一个参数包，参数包不能进行匹配，所以无法使用。

mylist.push_back({ 1, 'A' });

既然在用法上没什么区别，我们再通过前面自己实现的简单string来对比一下push_back与emplace_back的效率有什么差别

int main()
{
    
	std::list< std::pair<int, mlf::string> > mylist;
	mylist.emplace_back(10, "sort");
	mylist.emplace_back(make_pair(20, "sort"));
	cout << endl << endl;
	mylist.push_back(make_pair(30, "sort"));
	mylist.push_back({
     40, "sort" });

	return 0;
}

我们发现其实两者的效率其实也相差不大，emplace_back是直接构造了，而push_back是先构造，然后再移动构造。

lambda表达式

在C++98中，我们如果想对一个自定义类型按照特定的规则进行排序，那么我们就需要写一个仿函数

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算法， 都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C11语法中出现了Lambda表达式。

lambda表达式语法

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }

lambda表达式各部分说明：

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

下面我们来实现一个两个数相加的lambda

int main()
{
    
	//实现一个两个数相加的lambda
	auto add1 = [](int a, int b)->int{
    return a + b; };
	cout << add1(1, 2) << endl;
	return 0;
}

运行结果：

注意：在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

int main()
{
    
	[] {
    };//最简单的lambda表达式上面也不做
	// 省略参数列表和返回值类型，返回值类型由编译器推导为int
	int a = 3, b = 4;
	[=] {
    return a + 3; };
	
	// 省略了返回值类型，无返回值类型
	//引用传递捕捉a 和 b变量
	auto fun1 = [&](int c) {
    b = a + c; };
	fun1(10);
	cout << a << " " << b << endl;

	// 各部分都很完善的lambda函数
	//引用方式捕捉b，值传递捕捉其他所有变量
	auto fun2 = [=, &b](int c)->int {
    return b += a + c; };
	cout << fun2(10) << endl;

	// 值传递捕捉x
	int x = 10;
	auto add_x = [x](int a) mutable {
     x *= 2; return a + x; };
	cout << add_x(10) << endl;
	return 0;
}

通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要调用，可借助auto将其赋值给一个变量

捕获列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。

• [var]：表示值传递方式捕捉变量var
• [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
• [&var]：表示引用传递捕捉变量var
• [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
• [this]：表示值传递方式捕捉当前的this指针

注意：

1. 父作用域包含lambda函数的语句块

2. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割

   比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量，[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

3. 捕捉列表不允许变量重复传递，否则就会编译错误，比如：[=,a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

4. 在块作用域意外的lambda函数捕捉列表必须为空

   int a = 0, b = 1;
   //在全局中不能捕捉对象
   //auto func5 = [a, b](){};
   auto func5 = []{
         };
   

5. 在块作用域中的lambda函数仅能捕捉父作用域中的局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错

6. lambda表达式之间不能相互赋值，即使看起来类型相同

   void(*PF)();
   int main()
   {
         
   	auto f1 = []{
         cout << "hello world" << endl; };
   	auto f2 = []{
         cout << "hello world" << endl; };
   
   	//f1 = f2;//编译失败，提示找不到operator=()
   	//允许使用一个lambda表达式拷贝构造一个新的副本
   	auto f3(f2);
   	f3();
   
   	//可以将lambda表达式赋值给相同类型的函数指针
   	PF = f2;
   	PF();
   	return 0;
   }
   

现在学了lamda表达式之后，我们回到刚开始的代码，我们这一次不写仿函数而是使用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;
	});
	return 0;
}

运行结果：

价格升序

价格降序

评价升序

评价降序

可以看到我们使用了lambda表达式之后，相比仿函数而言lamdam表达式写起来一个方便了很多第二个代码的可读性也变高了。

函数对象与lambda表达式

函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了operator()运算符的类对象。

下面我们来看一段代码

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表达式完全一样。

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。

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

包装器

function包装器

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

那么我们来看一下，我们为什么要function呢？

下面我们先来看一段代码

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函数模板实例出了三份，函数名，函数对象，lambda表达式分别实例化了一份。

那有没有办法只实例化一份呢？

包装器可以很好的解决上面的问题

下面我们就来学习一下function包装器

std::function在头文件<functional>
    
//类模板原型如下
template<class T>
function;

template<class Ret,class ...Args>
class function<Ret(Args...)>
    
//模板参数说明：
Ret: 被调用函数的返回类型
Args...: 被调用函数的形参

下面我们先来用一下包装器

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

	double plusd(double a, double b)
	{
    
		return a + b;
	}
};

int main()
{
    
	function<int(int, int)> f1 = f;
	cout << f1(1, 2) << endl;

	function<int(int, int)> f2 = Functor();
	cout << f2(1, 2) << endl;

	function<int(int, int)> f3 = &Plus::plusi;
	cout << f3(1, 2) << endl;

	function<double(Plus, double, double)> f4 = &Plus::plusd;
	cout << f4(Plus(), 1.1, 2.2) << endl;

	return 0;
}

运行结果：

知道了包装器怎么使用之后，下面我们通过包装器来让上面的函数模板只实例化一次

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

运行结果：

可以count是累加的，并且count的地址是一样的，这说明函数模板只实例化了一次。

总结：

std::function可以包装各自可调用的对象，统一可调用对象的类型，指定参数和返回值类型。现在我们就能明白前面问的那个问题了：为什么要有包装器？

因为不包装前可调用类型存在很多问题

• 函数指针类型太复杂，不方便使用和理解
• 仿函数类型是一个类名，没有指定调用参数和返回值，得去看operator()的实现才能看出来
• lambda表达式在语法层，看不到类型。底层有类型，但是基本都是lambda_uuid，也很难看。