1 列表初始化

1.1 内置类型的列表初始化

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

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

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

template<class T>
class Vector {
public:
	// ... 
	Vector(initializer_list<T> l) : _capacity(l.size()), _size(0)
	{
		_array = new T[_capacity];
		for (auto e : l)
			_array[_size++] = e;
	}

	Vector<T>& operator=(initializer_list<T> l) {
		delete[] _array;
		size_t i = 0;
		for (auto e : l)
			_array[i++] = e;
		return *this;
	}
	// ...
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};


//自定义类型容器用初始化列表
//用自定义类型的容器类进行初始化，需要定义一个构造函数，参数为initializer_list
Vector<int> v2{ 1,2,3 };
Vector<int> v3 = { 1 };

2 decltype变量类型推导

decltype():根据表达式的实际类型推演出定义变量时所用的类型。

int fun(int a)
{
	return a;
}
void test01()
{
	auto a = 10;
	int b = 1;
	int c = 2;
	// 用decltype推演b+c的实际类型，作为定义d的类型
	decltype(b + c) d;
	cout << typeid(d).name() << endl;

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

	// 如果没有带参数，推导函数的类型
	cout << typeid(decltype(fun)).name() << endl;
}

3 默认成员控制

3.1 显示缺省函数

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

class A {
public:
 A(int a): _a(a)
 {}
 // 显式缺省构造函数，由编译器生成
 A() = default;
 //由编译器生成一个拷贝构造函数
 A(const A&a)=default;
 // 在类中声明，在类外定义时让编译器生成默认赋值运算符重载
 A& operator=(const A& a);
private:
 int _a;
};
A& A::operator=(const A& a) = default;
int main()
{
 A a1(10);
 A a2;
 a2 = a1;
 return 0; }

3.2 删除默认函数

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

//delete:该语法指示编译器不生成对应函数的默认版本，称 = delete修饰的函数为删除函数。
class B
{
public:
	B(){}
	//成员函数定义为删除函数，表示函数不能被调用
	//防拷贝：把拷贝构造和赋值运算符定义为delete
	// 禁止编译器生成默认的拷贝构造函数以及赋值运算符重载
	B(const B&) = delete;
	B& operator=(const B&) = delete;
};
void test()
{
	B b;
	// 编译失败，因为该类没有拷贝构造函数
	//B copy(b);

	// 编译失败，因为该类没有赋值运算符重载
	//b = copy;
}

4 右值引用

4.1 左值与右值

void test()
{
	//左值：可以出现现在“=”两边
	//右值：只能出现在“=”右边
	//左值：可以取地址
	//右值不：能取地址
	//但是上面两种分类都不是完全正确
	int a = 10;
	int b = a;
	//10 = b;//错误
	int* pa = &a;
	//int* pi = &10;

	//C++11中的区分方式
	//右值：常量、临时变量/匿名变量、将亡值
	b = fun(1);
	b = fun(a);
	//fun(a) = a;
	//右值不可以取地址
	//int* pa2 = &(fun(a));
}

4.2 左值引用与右值引用

// 普通引用只能引用左值，不能引用右值，const引用既可引用左值，也可引用右值
void test()
{
	//左值引用：可以引用左值
	int a = 10;
	int& ra = a;
	//常量引用
	const int& ri = 10;
	const int& ri2 = fun(a);

	//右值引用&&：只能引用右值，不能引用左值
	//int&& ra = a;
	int&& rri = 10;
	int&& tt = fun(a);
}

4.3 移动语义

class String
{
public:
 String(char* str = "")
 {
 if (nullptr == str)
 str = "";
 _str = new char[strlen(str) + 1];
 strcpy(_str, str);
 }
 
 String(const String& s)
 : _str(new char[strlen(s._str) + 1])
 {
 strcpy(_str, s._str);
 }
 String& operator=(const String& s)
 {
 if (this != &s)
 {
 char* pTemp = new char[strlen(s._str) +1];
 strcpy(pTemp, s._str);
 delete[] _str;
 _str = pTemp;
 }
 return *this;
 }
 
 String operator+(const String& s)
 {
 char* pTemp = new char[strlen(_str) + strlen(s._str) + 1];
 strcpy(pTemp, _str);
 strcpy(pTemp + strlen(_str), s._str);
 String strRet(pTemp);
 return strRet;
 }
~String()
{ if (_str) delete[] _str;}
private:
 char* _str;
};
int main()
{
 String s1("hello");
 String s2("world");
 String s3(s1+s2);
 return 0; }

strRet在按照值返回时，必须创建一个临时对象，临时对象创建好之后，strRet就被销毁了，最后使用返回的临时对象构造s3，s3构造好之后，临时对象就被销毁了。仔细观察会发现：strRet、临时对象、s3每个对象创建后，都有自己独立的空间，而空间中存放内容也都相同，相当于创建了三个内容完全相同的对象，对于空间是一种浪费，程序的效率也会降低，而且临时对象确实作用不是很大。

//移动构造：使用移动语义，把对象中的资源移动到另一个对象
class String
{
public:
	String(char* str = "")
	{
		if (nullptr == str)
			str = "";
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}

	String(const String& s)
		: _str(new char[strlen(s._str) + 1])
	{
		strcpy(_str, s._str);
	}
	String& operator=(const String& s)
	{
		if (this != &s)
		{
			char* pTemp = new char[strlen(s._str) + 1];
			strcpy(pTemp, s._str);
			delete[] _str;
			_str = pTemp;
		}
		return *this;
	}
//右值引用，浅拷贝
	String(String&& s)
		:_str(s._str)
	{
		s._str = nullptr;
		cout << "String(String&& s)" << endl;
	}
	String& operator=(String&& s)
	{
		if (this != &s)
		{
			_str = s._str;
			s._str = nullptr;
		}
	}
	String operator+(const String& s)
	{
		char* pTemp = new char[strlen(_str) + strlen(s._str) + 1];
		strcpy(pTemp, _str);
		strcpy(pTemp + strlen(_str), s._str);
		String strRet(pTemp);
		return strRet;
	}

	~String()
	{
		if (_str) delete[] _str;
	}
private:
	char* _str;
};
int main()
{
	String s1("hello");
	String s2("world");
	cout << "copy" << endl;
	String s3(s1 + s2);
	String s4(s2);
	cout << "---" << endl;
	s4=s1+s2;
	cout << "-----" << endl;
}

因为strRet对象的生命周期在创建好临时对象后就结束了，即将亡值，C++11认为其为右值，在用strRet构造临时对象时，就会采用移动构造，即将strRet中资源转移到临时对象中。而临时对象也是右值，因此在用临时对象构造s3时，也采用移动构造，将临时对象中资源转移到s3中，整个过程，只需要创建一块堆内存即可，既省了空间，又大大提高程序运行的效率。

4.4 右值引用引用左值

int main()
{
	String s1("hello");
	String s2("world");
	cout << "copy" << endl;
	String s3(s1 + s2);
	String s4(s2);
	cout << "---" << endl;
	s4=s1+s2;
	cout << "-----" << endl;

	//move:将一个左值强制转化为右值引用，然后实现移动语义
	String&& rs = std::move(s3);

	//错误的使用
	//s3将资源转移到s6,s3的资源将无法使用，s3变为无效字符串
	String s6(move(s3));
	return 0;
}

正确使用move的例子

class Person
{
public:
 Person(char* name, char* sex, int age)
 : _name(name)
 , _sex(sex)
 , _age(age)
 {}
 
 Person(const Person& p)
 : _name(p._name)
 , _sex(p._sex)
 , _age(p._age)
 {}
 
#if 0
 
 Person(Person&& p)
 : _name(p._name)
 , _sex(p._sex)
 , _age(p._age)
 {}
 
#else
Person(Person&& p)
 : _name(move(p._name))
 , _sex(move(p._sex))
 , _age(p._age)
 {}
 
#endif
 
private:
 String _name;
 String _sex;
 int _age;
};
Person GetTempPerson()
{
 Person p("prety", "male", 18);
 return p; }
int main()
{
 Person p(GetTempPerson());
 return 0; }

4.5 完美转发

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

//C++11通过forward<T>()函数来实现完美转发
void Fun(int& x) { cout << "lvalue ref" << endl; }
void Fun(int&& x) { cout << "rvalue ref" << endl; }
void Fun(const int& x) { cout << "const lvalue ref" << endl; }
void Fun(const int&& x) { cout << "const rvalue ref" << endl; }
template<typename T>
//T&&：未定义引用类型，并不是右值引用
void PerfectForward(T&& t) { Fun(std::forward<T>(t)); }
int main()
{
	PerfectForward(10); // rvalue ref

	int a;
	PerfectForward(a); // lvalue ref
	PerfectForward(std::move(a)); // rvalue ref
	const int b = 8;
	PerfectForward(b); // const lvalue ref
	PerfectForward(std::move(b)); // const rvalue ref
	return 0;
}

5 lambda表达式

5.1 什么是仿函数

struct Greater
{
	//仿函数类：重载()
	bool operator()(const T& a, const T& b)
	{
		return a > b;
	}
};
struct MyPlus {
	int operator()(const int& a, const int& b) const {
		return a + b;
	}
};
void test01()
{
	Greater<int> g;
	bool ret=g.operator()(10, 20);
	ret = g(10, 20);//等价于g.operator()(10,20)
}
void test02()
{
	MyPlus a;
	cout << MyPlus()(1, 2) << endl;//1、通过产生临时对象调用重载运算符
	cout << a.operator()(1, 2) << endl;//2、通过对象显示调用重载运算符
	cout << a(1, 2) << endl;//3、通过对象类似函数调用 隐示地调用重载运算符
	return 0;
}

5.2 为什么要写lambda表达式

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。

int main()
{
 int array[] = {4,1,8,5,3,7,0,9,2,6};
 
 // 默认按照小于比较，排出来结果是升序
 std::sort(array, array+sizeof(array)/sizeof(array[0]));
 
 // 如果需要降序，需要改变元素的比较规则
 std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
 return 0; }

如果待排序元素为自定义类型，需要用户定义排序时的比较规则：

struct Goods
{
 string _name;
 double _price;
};
struct Compare
{
 bool operator()(const Goods& gl, const Goods& gr)
 {
 return gl._price <= gr._price;
 }
};
int main()
{
 Goods gds[] = { { "苹果", 2.1 }, { "相交", 3 }, { "橙子", 2.2 }, {"菠萝", 1.5} };
 sort(gds, gds+sizeof(gds) / sizeof(gds[0]), Compare());
 return 0; }

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一algorithm算法， 都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C11语法中出现了Lambda表达式。

int main()
{
 Goods gds[] = { { "苹果", 2.1 }, { "相交", 3 }, { "橙子", 2.2 }, {"菠萝", 1.5} };
 sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& l, const Goods& r)
 ->bool
 {
 return l._price < r._price;
 });
 return 0; }

上述代码就是使用C++11中的lambda表达式来解决，可以看出lamb表达式实际是一个匿名函数。

5.3 lambda表达式语法

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

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

void test()
{
	//lamba表达式：[捕捉列表](参数列表）（mutable可选）->返回值类型（函数体）
	//捕捉列表：捕获父作用域中的变量
	int a = 10;
	int b = 20;
	[a, b] {return a + b; };
	//参数列表：类似函数列表
	[a, b](int c, int d, int e) {return a + b + c; };
	//返回值：类似函数返回值
	[a, b](int c)->int {return a + b + c; };
	//函数体：类似于函数的函数体，可以有多句指令
	//mutable:修改捕捉列表中变量的属性为非const,默认const属性
	//[a, b](int c)->int {a = 10};//a,b的属性不能修改创，默认为const
	//要修改捕捉列表中的值，需要加mutable关键字
	[a, b](int c)mutable->int {a = 100; b = 200; return a; };
	//在没有mutable的情况下，参数列表返回值可以省略
	[] {};
	//返回值类性一般不用写，编译器会自动推导
	[a, b] {return a + b; };
	//如果有mutable，即使参数列表为空，也需要显示写出来
	//[a, b]mutable {return a + b; };
	[a, b]()mutable {return a + b; };
	auto f = [a, b](int c) {return a + b + c; };
	//以上都是定义，不会运行
	//运行
	int e = f(10);

	//[=],以值的形式捕捉父作用域中的所有变量
	auto f2 = [=] {return a + b + e; };
	//[&],以引用的方式捕捉父作用域中的所有变量
	auto f3 = [&]() {a = 1; b = 1000; };
	//[=,&变量x]:x引用形式捕捉，其他的以值的形式捕捉
	//错误的捕捉方式：[=,变量x],[&,&变量x]
	//[&,变量x]:x值得形式捕捉。其他的以引用的形式捕捉
	auto f4 = [&, a]() {return a + b; };
	auto f5 = [=, &a, &e]() {return a + b + e; };
	//[this]:捕捉成员函数的this指针
	struct A
	{
		void fun(int a)
		{
			auto f = [this]() {return _a; };
		}
		int _a;
	};
}

5.4 lambda表达式的性质

//lambda表达式一些性质
typedef int(*ptr)(int);
void test()
{
	auto f = [](int a) {return a; };
	auto f2 = [](int a) {return a; };
	//1.lambda表达式不能进行赋值，即使类型相同
	//f = f2;
	//2.允许lambda表达式拷贝
	auto copy(f);
	//3.可以赋值给函数指针
	ptr f4 = f;

}

//如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()
struct Sum
{
	int operator()(int a, int b)
	{
		return a + b;
	}
};
void test()
{
	auto f = [](int a, int b) {return a + b; };
	int sum = f(10, 20);

	Sum s;
	s(10, 20);
}

5.5 线程库

//线程库
void fun(int a)
{
	cout << "fun(int a)" << endl;

}
struct Fun
{
	void operator()()
	{
		cout << "Fun operator()" << endl;
	}
};
void test()
{
	
	thread t();
	// 1.线程函数为函数指针
	thread t1(fun, 10);
	//判断线程是否结束
	t1.joinable();
	//阻塞进程
	t1.join();

	//2.仿函数对象
	Fun f;
	thread t2(f);
	t2.join();

	//3.lambda表达式
	thread t3([] {cout << "lambda" << endl; });
	t3.join();
}

5.6 线程函数参数

class A
{
public:
	void fun1(int a, int b)
	{
		cout << "fun1(int,int)" <<" "<< a <<" "<< b << endl;

	}
};
void fun(int& a)
{
	a += 10;
}
void fun1(int* atr)
{
	*atr += 10;
}
void test()
{
	A a;
	//成员函数需要显示取地址
	thread t1(&A::fun1, &a,10, 20);
	t1.join();
	// 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际引用的是线程栈中的拷贝
	/*int a2 = 1;
	thread t2(fun, a2);
	t2.join();

	cout << a2 << endl;*/
	 地址的拷贝
	int a3 = 1;
	thread t3(fun1, &a3);
	cout << a3 << endl;
	t3.join();

	//参数如果是引用类型,需要加ref转换
	thread t4(fun, ref(a3));
	cout << a3 << endl;
	t4.join();

}

5.7 join与detach

启动了一个线程后，当这个线程结束的时候，如何去回收线程所使用的资源呢？thread库给我们两种选择：
join()方式
join()：主线程被阻塞，当新线程终止时，join()会清理相关的线程资源，然后返回，主线程再继续向下执行，然后销毁线程对象。由于join()清理了线程的相关资源，thread对象与已销毁的线程就没有关系了，因此一个线程对象只能使用一次join()，否则程序会崩溃。
detach()方式
detach()：该函数被调用后，新线程与线程对象分离，不再被线程对象所表达，就不能通过线程对象控制线程了，新线程会在后台运行，其所有权和控制权将会交给c++运行库。同时，C++运行库保证，当线程退出时，其相关资源的能够正确的回收。
就像是你和你女朋友分手，那之后你们就不会再有联系（交互）了，而她的之后消费的各种资源也就不需要你去埋单了（清理资源）。
****detach()函数一般在线程对象创建好之后就调用，因为如果不是jion()等待方式结束，那么线程对象可能会在新线程结束之前被销毁掉而导致程序崩溃。因为std::thread的析构函数中，如果线程的状态是jionable，std::terminate将会被调用，而terminate()函数直接会终止程序。

void fun2(int n)
{
	for (int i= 0; i < n; i++)
	{
		cout << i << " ";
	}
	cout << "fun2..." << endl;
}
void test()
{
	//detach()：该函数被调用后，新线程与线程对象分离，不再被线程对象所表达，就不能通  //过线程对象控制线程了，新线程会在后台运行，其所有权和控制权将会交给c++运行库。同时//C++运行库保证，当线程退出时，其相关资源的能够正确的回收。

	thread t1(fun2, 1000);
	t1.detach();
	cout << "test" << endl;
}

//采用jion()方式结束线程时，jion()的调用位置非常关键。为了避免该问题，可以采用RAII的方式对线程对象进行封装，
class ThreadManger
{
public:
	ThreadManger(thread& t)
		:_t(t)
	{}
	~ThreadManger()
	{
		if (_t.joinable())
		{
			_t.join();
		}
	}

private:
	thread& _t;
};
void test()
{
	thread t1([] {});
	ThreadManger tm(t1);
	vector<int> v;
	v.at(3) = 10;
	//在这会正常结束
	//return;
	t1.join();
}
int main()
{
	try
	{
		test();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

5.8 原子操作

多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦。比如：

#include <iostream>
using namespace std;
#include <thread>
unsigned long sum = 0L;
void fun(size_t num) {
 for (size_t i = 0; i < num; ++i)
 sum++; }
int main()
{
 cout << "Before joining,sum = " << sum << std::endl;
 thread t1(fun, 10000000);
 thread t2(fun, 10000000);
 t1.join();
 t2.join();
 cout << "After joining,sum = " << sum << std::endl;
 return 0; }

C++98中传统的解决方式：可以对共享修改的数据可以加锁保护。

#include <thread>
#include <mutex>
std::mutex m;
unsigned long sum = 0L;
void fun(size_t num) {
 for (size_t i = 0; i < num; ++i)
 {
 m.lock();
 sum++;
 m.unlock();
 }
}
int main()
{
 cout << "Before joining,sum = " << sum << std::endl;
 thread t1(fun, 10000000);
 thread t2(fun, 10000000);
 t1.join();
 t2.join();
 cout << "After joining,sum = " << sum << std::endl;
 return 0; }

虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。
因此C++11中引入了原子操作。所谓原子操作：即不可被中断的一个或一系列操作，C++11引入的原子操作类型，使得线程间数据的同步变得非常高效。

//原子操作
atomic<int> sum(0);
void fun(int n)
{
	for (int i = 0; i < n; i++)
	{
		//不是原子操作，加atomic串行操作,或者加解锁
		//mtx.lock();
		sum++;
		//mtx.unlock();
	}
}
void test()
{
	int n;
	cin >> n;
	thread t1(fun, n);
	thread t2(fun, n);
	t1.join();
	t2.join();
	cout << sum << endl;
}

5.9 lock_guard

//死锁
mutex mtx;
template<class Mtx>
class LockGuard
{
public:
	LockGuard(Mtx& mtx)
		:_mtx(mtx)
	{
		//在构造函数中加锁
		mtx.lock();
	}
	~LockGuard()
	{
		//在析构函数中解锁
		mtx.unlock();
	}
	//保证一把锁只能被一个对象管理
	LockGuard& operator=(const LockGuard&) = delete;
	LockGuard(const LockGuard&) = delete;
private:
	Mtx& _mtx;
};
void fun1()
{
	//通过智能指针自动管理资源
	LockGuard<mutex> lg(mtx);;
	cout << "fun1()" << endl;
	int n;
	cin >> n;
	//两个函数用同一把锁，在这里会产生死锁
	//因为这里发生异常，线程直接退出，fun2()产生死锁
	//通过lock_guard可以有效避免死锁
	if (n == 0)
		return;
	mtx.unlock();
}
void fun2()
{
	LockGuard<mutex> lg(mtx);
	mtx.lock();
	cout << "fun2()" << endl;
	mtx.unlock();
}
void test()
{
	thread t1(fun1);
	thread t2(fun2);
	t1.join();
	t2.join();
}

通过上述代码可以看到，lock_guard类模板主要是通过RAII的方式，对其管理的互斥量进行了封装，在需要加锁的地方，只需要用上述介绍的任意互斥体实例化一个lock_guard，调用构造函数成功上锁，出作用域前，lock_guard对象要被销毁，调用析构函数自动解锁，可以有效避免死锁问题。