1.完美转发

1.1 模板中的&& ---万能引用

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值,模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力。

如下面的代码，T&&在这里就代表了万能引用，既可以接收左值，又可以接收右值。

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

我们看以下代码：

PeffectForward分别接收了左值，右值，const左值，const右值，由它调用的func函数应当调用相对的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;
}

但是调用结果却和我们想象的不一样，这就是我们万能模板的存在的缺点，当他引用右值的时候，会退化成左值，知道这点之后这样的结果就说的通了。这时，我们就需要这里讲到的完美发forward关键字，他可以保留对象原生类型属性。

这样修改后代码的结果便和我们的预期相符合了

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

2.新的类功能

默认成员函数

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

1. 构造函数

2. 析构函数

3. 拷贝构造函数

4. 拷贝赋值重载

5. 取地址重载

6. const 取地址重载

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

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

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

1.如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类 型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

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

3.如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

强制生成默认函数的关键字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;
    }

禁止生成默认函数的关键字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;
}

3.可变参数模板

C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比

C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改

进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。现

阶段呢，我们掌握一些基础的可变参数模板特性就够我们用了，所以这里我们点到为止，以后大

家如果有需要，再可以深入学习。

最简单的可变参数模板的的函数模板

template<class ... Args> //Args 是一个模板参数包
void Showlist(Args... ars) //args是函数的形参参数包  //这个函数包可以包含0到任意个参数
{

}

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数

包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，

只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特

点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变

参数，所以我们的用一些奇招来一一获取参数包的值

递归函数方式展开参数包

我们通过递归的方式来打印里面的参数，当传入（1，2，3，4，5，6，7，8，9，0）时，会调用第三个Showlist函数，将第一个参数 1 传给了value ，每次调用都会少一个值，直到参数包只有一个参数时，就会调用第一个Showlist函数。这样我们就将参数包里面所有的值都打印出来了。

template<class T>
void Showlist(const T& t)
{
	cout << t << " ";
}

void Showlist()
{
	
}

template<class T , class ... Args> //Args 是一个模板参数包
void Showlist(const T& value , Args... ars) //args是函数的形参参数包  
                                            //这个函数包可以包含0到任意个参数
{
	cout << value << " ";
	Showlist(ars...);
}


int main()
{

	Showlist(1,2,3,4,5,6,7,8,9,0);
	return 0;
}

我们还可以通过一个函数打印除参数包里面的个数：在sizeof后面加上 ... 在加上形参参数包

template<class ... Args>
void Func(Args... args)
{
	cout << sizeof...(args) << endl;
}

逗号表达式展开参数包

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

int main()
{
	// 最简单的lambda表达式, 该lambda表达式没有任何意义
	[] {};

	// 省略参数列表和返回值类型，返回值类型由编译器推导为int
	int a = 3, b = 4;
	[=] {return a + 3; };

	// 省略了返回值类型，无返回值类型
	auto fun1 = [&](int c) {b = a + c; };
	fun1(10);
		cout << a << " " << b << endl;

	// 各部分都很完善的lambda函数 //这里的&b是&操作符的一个特列，这里表示捕捉所有的值但是 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;
}