1. 类型推导

1.1 auto

• auto可以让编译器在编译期就推导出变量的类型
  • auto的使⽤必须⻢上初始化，否则⽆法推导出类型
  • auto在⼀⾏定义多个变量时，各个变量的推导不能产⽣⼆义性，否则编译失败
  • auto不能⽤作函数参数
  • 在类中auto不能⽤作⾮静态成员变量
  • auto不能定义数组，可以定义指针
  • auto⽆法推导出模板参数
  • 在不声明为引⽤或指针时，auto会忽略等号右边的引⽤类型和const（常量）、volatile（易变性）限定
  • 在声明为引⽤或者指针时，auto会保留等号右边的引⽤和cv属性

1.2 decltype

• ⽤于推导表达式类型，这⾥只⽤于编译器分析表达式的类型，表达式实际不会进⾏运算
• decltype不会像auto⼀样忽略引⽤和cv属性，decltype会保留表达式的引⽤和cv属性
• 对于decltype(exp)，若exp是表达式，decltype(exp)和exp类型相同；若exp是函数调⽤，decltype(exp)和函数返回值类型相同；若exp是左值，decltype(exp)是exp类型的左值引⽤。
• auto和decltype配合使用：

template<typename T, typename U>
auto add(T t, U u)->decltype(t + u){
	return t + u;
}

2. 范围for循环

• 基于范围的迭代写法，for（变量：对象）表达式：

string str ("some thing");
for(char c : str) cout << c << endl;

• 对vector中的元素进⾏遍历：

vector<int> arr(5, 100);
for(vector<int>::iterator i = arr.begin(); i != arr.end(); ++i) cout << *i << endl;
for(auto &i : arr) cout << i << endl;

3. 右值引用

3.1 左值和右值

• 左值：可以放在等号左边，可以取地址并有名字
• 右值：不可以放在等号左边，不能取地址，没有名字
  • 其定义形式为：Type &&var；其中 Type 表示变量的类型，var 表示变量名。
• ++i、–i是左值，i++、i–是右值

3.2 左值引用和右值引用

• 左值引用：
  • 左值引⽤就是对左值进⾏引⽤的类型，是对象的⼀个别名
  • 并不拥有所绑定对象的堆存，所以必须⽴即初始化。 对于左值引⽤，等号右边的值必须可以取地址，如果不能取地址，则会编译失败，或者可以使⽤const引⽤形式
• 右值引用：
  • 右值引用所引用的对象是一个右值，右值对象是指其生命周期即将结束的对象，例如一次函数调用的返回值、临时变量等。
  • 表达式等号右边的值需要是右值，可以使⽤std::move函数强制把左值转换为右值

3.3 右值引用的使用场景

• 以字符串类为例，假设有一个字符串对象 A，我们要把它赋值给另外一个字符串对象 B

string A = "HELLO";
string B = A;

• 这样做的结果是，我们创建了两个相同内容但是不同地址的字符串对象，其中一个占用了额外的内存，存在性能问题。
• 为了解决这个问题，C++11 移动语义提供了将对象 A 移动到 B 中的操作:
  • 当我们需要把一个对象赋值给另一个对象时，编译器会调用其复制构造函数或者赋值构造函数来创建一个新对象。但是，在某些情况下，复制操作会非常耗时；如果复制操作是不必要的，此时，使用移动构造函数，它不需要复制整个对象，而只是需要将原对象中的指针等资源转移到目标对象中即可，这样可以提高复制性能。

string A = "HELLO";
string B = std::move(A);

• 上述代码就可以把对象 A 移动到 B 中，并不需要创建新的对象和分配内存。
• 需要注意的是，只能对一个右值引用或者一个将要销毁的对象调用 std::move() 函数，否则会导致潜在的内存问题和错误。此外，在使用右值引用时，需要注意数据的生命周期问题，不要在使用后再次使用已经被移动的对象。

3.4 forward 完美转发

• forward 完美转发实现了参数在传递过程中保持其值属性的功能，即若是左值，则传递之后仍然是左值，若是右值，则传递之后仍然是右值。
• &&既可以对左值引用，亦可以对右值引用，但它后面的val值本身是个左值；&只能左值引用

template <class T>
void Print(T &t){ cout << "L" << t << endl; }
template <class T>
void Print(T &&t){ cout << "R" << t << endl; }

template <class T>
void func(T &&t){
	Print(t);    
	Print(move(t));    
	Print(forward<T>(t));
}

int main(){
	cout << "-- func(1) --" << endl;    
	func(1);  
	
	cout << "-- func(x) --" << endl;  
	int x = 10;    
	int y = 20;    
	func(x);  // x本身是左值    
	
	cout << "-- func(forward<int>(y)) --" << endl;    
	func(forward<int>(y)); //T为int，以右值方式转发y    
	
	cout << "-- func(forward<int&>(y)) --" << endl;    
	func(forward<int&>(y));    
	
	cout << "-- func(forward<int&&>(y)) --" << endl;    
	func(forward<int&&>(y));    
	
	return 0;
}

运行结果：

3.5 emplace_back 减少内存拷贝和移动

• emplace_back能就地通过参数构造对象，不需要拷贝或者移动内存，相比 push_back能更好地避免内存的拷贝与移动，使容器插入元素的性能得到进一步提升。在大多数情况下应该优先使用emplace_back来代替push_back。

4. lambda 匿名函数

• 表示⼀个可调⽤的代码单元，没有命名的内联函数，不需要函数名因为我们直接（⼀次性的）⽤它，不需要其他地⽅调⽤它
• 一般情况下，编译器可以自动推断出lambda表达式的返回类型，所以我们可以不指定返回类型。但是如果函数体内有多个return语句时，编译器无法自动推断出返回类型，此时必须指定返回类型。
• 语法：[ 捕获列表 ] (参数列表) -> 返回类型 { 函数体 }

int main(){
	auto Add = [](int a, int b)->{ return a+b; };
	cout << Add(1, 2) << endl;
	return 0;
}

值捕获

void func() {     // c=10 d=20 add(1,2)=23
	int c = 10;
	int d = 20;
	auto add = [c, d](int a, int b) {
		cout << "c=" << c << endl;
		cout << "d=" << d << endl;
		return d+a+b;
	};
	d = 50;
	cout << "add(1, 2)=" << add(1, 2) << endl;
}

引用捕获

void func() {    // c=1 d=50 add(1,2)=53
	int c = 10;
	int d = 20;
	auto add = [&c, &d](int a, int b) {
		c = a;
		cout << "c=" << c << endl;
		cout << "d=" << d << endl;
		return d+a+b;
	};
	d = 50;
	cout << "add(1, 2)=" << add(1, 2) << endl;
}

隐式捕获、空捕获

void func() {
	int c = 10;
	int d = 20;
	// 如果[&]代表引用捕获，[=]代表值捕获，如果[]为空捕获表示Lambda不能使用所在函数中的变量
	auto add = [&](int a, int b) {  
		c = a; 
		cout << "c=" << c << endl;
		cout << "d=" << d << endl;
		return d+a+b;
	};
	d = 50;
	cout << "add(1, 2)=" << add(1, 2) << endl;
}

表达式捕获

// c++14之后支持捕获右值，允许捕获的成员用任意的表达式进行初始化，被声明的捕获变量类型会根据 表达式进行判断，判断方式与使用 auto 本质上是相同的
void func4() {
	auto p = make_unqiue<int>(1);
	auto add = [v1=1, v2=move(p)](int x, int y)->int{ return x+y+v1+(*v2); };
	cout << "add(1, 2)=" << add(1, 2) << endl;
}

泛型捕获

void func() {
	auto add = [](auto x, auto y){ return x+y; };
	cout << "add(1, 2)=" << add(1, 2) << endl;
	cout << "add(1.1, 2.2)=" << add(1.1, 2.2) << endl;
}

可变

// 采用值捕获的方式，lambda不能修改其值，如果想要修改，使用mutable修饰；或者采用引用捕获的方式
void func() {
	int v = 5;
	auto ff = [v]() mutable { return ++v; };
	v = 0;
	auto j = ff(); // ff捕获的是值，即为5，因此j为6

	int m = 5;
	auto gg = [&m] {return ++m; };
	m = 0;
	auto n = gg(); // gg捕获的是引用，即为0，因此n为1
}