【C++】C++11中的常见语法(下)

一、可变参数模板

C++11 的新特性可变参数模板能够让我们创建可以接受可变参数的函数模板和类模板，相比 C++98/03 ，类模版和函数模版中只能含固定数量的模版参数，可变模版参数是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的。所以我们只需要掌握一些基础的可变参数模板特性够了，如果大家有需要，再可以深入去学习。

其实我们早就接触过可变参数了，例如 printf 函数，这个是函数的可变参数，如下图：

… 代表可以传任意个参数。

以下是可变参数模板的语法：

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

我们可以像以下这样传参：

				int main()
				{
					ShowList(1, 2, 3, 4, 5);
					ShowList(1, "abcde", 3.33);
				
					return 0;
				}

我们可以通过 sizeof...(args) 计算出参数包的个数，如下：

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

如果我们想打印参数包中的内容呢？我们无法直接获取参数包 args 中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用 args[i] 这样方式获取可变参数，所以我们的用一些其他方式来一一获取参数包的值。

1. 递归函数方式展开参数包

如以下代码：

				// 递归终止函数
				void _ShowList()
				{
					cout << endl;
				}
				
				// 展开函数
				template <class T, class ...Args>
				void _ShowList(const T& val, Args... args)
				{
					cout << val << " ";
					_ShowList(args...);
				}
				
				template <class ...Args>
				void ShowList(Args... args)
				{
					_ShowList(args...);
				}
				
				int main()
				{
					ShowList(1, 2, 3, 4, 5);
					ShowList(1, "abcde", 3.33);
				
					return 0;
				}

如上代码，我们就可以打印出参数包的内容，这种方法叫做编译时的递归推演。

2. 逗号表达式展开参数包

这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, PrintArg 不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。

如下代码：

				template <class T>
				int PrintArg(T t)
				{
					cout << t << " ";
					return 0;
				}
				
				//展开函数
				template <class ...Args>
				void ShowList(Args... args)
				{
					int arr[] = { PrintArg(args)... };
					cout << endl;
				}

上述代码中，要初始化 arr，就强行让编译器解析参数包，参数包有几个参数，PrintArg 就依次推演生成几个参数。

3. STL容器中的 empalce 相关接口函数

C++11中为容器新增了一些 empalce 的插入接口，首先我们看到的 emplace 系列的接口，支持模板的可变参数，并且万能引用。那么相对 insert 和 emplace 系列接口的优势到底在哪里呢？

我们先尝试一下使用两种方法插入一些数据，如下：

				int main()
				{
					list<Young::string> lt;
					Young::string s1("abcde");
				
					lt.push_back(s1);
					lt.push_back(move(s1));
				
					Young::string s2("edcba");
					lt.emplace_back(s2);
					lt.emplace_back(move(s2));
				
					return 0;
				}

但是我们发现，在这种情况下两者并没有明显的区别，那么它们的区别到底在哪呢？

下面我们换一种初始化方式，我们在构造函数中也打印相应的语句，这样有利于我们观察：

				int main()
				{
					list<Young::string> lt;
				
					lt.push_back("abcde");
					lt.emplace_back("abcde");
				
					return 0;
				}

结果如下：

其中 push_back 调的是构造和移动构造；emplace_back 只调了构造，这是为什么呢？原因如下图所示：

下面我们再看一种场景，多参数传参：

				int main()
				{
					list<pair<Young::string, int>> lt;
				
					lt.push_back(make_pair("abcde", 1));
					cout << endl;
				
					lt.emplace_back("edcba", 2);
				
					return 0;
				}

其原因也与上述的类似：

下面我们更改一下我们自己实现的 list 类，增加 emplace_back 版本的插入，为了方便演示上述过程：

首先增加构造节点的构造函数：

					template <class... Args>
					list_node(Args&&... args)
						: _data(args...)
						, _next(nullptr)
						, _prev(nullptr)
					{}

再增加 emplace_back 的插入版本，这里没有实现后面链接的部分代码，只是为了演示这个过程：

				template <class... Args>
				void emplace_back(Args&&... args)
				{
					Node* newnode = new Node(args...);
					// 链接节点
					// ...
				}

emplace_back 版本的插入过程如下图所示：

结论：emplace_back 比 push_back 略微高效一点点，并没有很大的提升，因为移动构造的成本也是足够低的！

二、lambda 表达式

1. C++98 中的一个例子

在 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; // 价格
					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;
					}
				};

其中，sort 中的 Compare comp 是一个可调用对象：

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

2. 使用 lambda 表达式

我们可以先见识一下如何使用 lambda 表达式；如果想使用 lambda 表达式达到上面的比较效果，假设我们需要分别写一个按照商品的价格的高低的排序，如下：

			int main()
			{
				vector<Goods> v = { 
					{ "苹果", 2.1, 5 }, 
					{ "香蕉", 3, 4 }, 
					{ "橙子", 2.2,3 }, 
					{ "菠萝", 1.5, 4 } 
				};
				
				// lambda 表达式
				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; });
			
				return 0;
			}

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

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 函数不能做任何事情。

由于 lambda 表达式是一个可调用对象，所以也可以像下面一样写：

				int main()
				{
					auto f1 = [](int x) {cout << x << endl; return 0; };
					f1(10);
				
					return 0;
				}

我们也可以查看一下 lambda 表达式的类型：

如上图，我们可以看到，lambda 表达式的类型是一个类，这个类的名称是 lambda + uuid. 每个 lambda 都会生成一个类。

（2）捕获列表说明

捕捉列表描述了上下文中哪些数据可以被 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 函数捕捉列表必须为空；
5. 在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错；
6. lambda 表达式之间不能相互赋值，即使看起来类型相同。

4. 函数对象与 lambda 表达式

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

如下分别为仿函数和 lambda：

				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);
				
					// lambda
					auto r2 = [=](double monty, int year) {return monty * rate * year; };
					r2(10000, 2);
				
					return 0;
				}

从使用方式上来看，函数对象与 lambda 表达式完全一样。

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

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

三、包装器

1. function 包装器

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

要学包装器，首先需要知道包装器包装的是什么？其实包装器包装的是可调用对象，目前我们学习到的可调用对象有：函数指针、仿函数、lambda，我们要学的包装器就是要包装它们三个中的任意一个。

其中，函数指针的设计不太好，不符合我们常规的写法，例如：void (*pswap)(int* p1, int* p2)，这种方式不好写，类型也不好写。

而仿函数类型比较好写，但是它比较重，它得在全局里面单独定义一个类，即使是写一个很简单的比较，也是需要定义一个类，这种方法太笨重了。

而 lambda 比较灵活，但是 lambda 也和函数指针面临同样的问题，类型不好写，类型是匿名的。

我们先来看看 function 包装器的语法：

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

下面我们来简单使用一下包装器包装可调用对象，假设我们需要包装一个实现两个数交换的可调用对象，如下，先包装函数指针：

				void swap_func(int& x, int& y)
				{
					int tmp = x;
					x = y;
					y = tmp;
				}

				int main()
				{
					int x = 10, y = 20;
					cout << "x = " << x << " " << "y = " << y << endl;
				
					// 包装函数指针
					function<void(int&, int&)> f1 = swap_func;
					f1(x, y);
					cout << "x = " << x << " " << "y = " << y << endl;
				
					return 0;
				}

如上图，我们完成对函数指针的包装。

包装函数对象和 lambda：

				int main()
				{
					int x = 10, y = 20;
					cout << "x = " << x << " " << "y = " << y << endl;
				
					auto swap_lambda = [](int& r1, int& r2)
					{
						int tmp = r1;
						r1 = r2;
						r2 = tmp;
					};
				
					// 包装函数指针
					function<void(int&, int&)> f1 = swap_func;
					f1(x, y);
					cout << "x = " << x << " " << "y = " << y << endl;
				
					// 包装函数对象
					function<void(int&, int&)> f2 = Swap();
					f2(x, y);
					cout << "x = " << x << " " << "y = " << y << endl;
				
					// 包装 lambda
					function<void(int&, int&)> f3 = swap_lambda;
					f3(x, y);
					cout << "x = " << x << " " << "y = " << y << endl;
				
					return 0;
				}

但是在实际中我们并不像上面的这样用，假设我们需要将可调用对象放入一个容器中，假设是 map，就可以像下面这样包装：

				map<string, function<void(int&, int&)>> cmdOP = {
						{"函数指针", swap_func},
						{"仿函数", Swap()},
						{"lambda", swap_lambda}
					};

我们在使用的时候，就像在使用对应的命令去调对应的函数一样，这就是回调：

				int main()
				{
					int x = 10, y = 20;
					cout << "x = " << x << " " << "y = " << y << endl << endl;
				
					auto swap_lambda = [](int& r1, int& r2)
					{
						int tmp = r1;
						r1 = r2;
						r2 = tmp;
					};
				
					map<string, function<void(int&, int&)>> cmdOP = {
						{"函数指针", swap_func},
						{"仿函数", Swap()},
						{"lambda", swap_lambda}
					};
				
					cmdOP["函数指针"](x, y);
					cout << "x = " << x << " " << "y = " << y << endl;
				
					cmdOP["仿函数"](x, y);
					cout << "x = " << x << " " << "y = " << y << endl;
				
					cmdOP["lambda"](x, y);
					cout << "x = " << x << " " << "y = " << y << endl;
				
					return 0;
				}

2. 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 为第二个实参，以此类推。

使用举例：

				int Sub(int a, int b)
				{
					return a - b;
				}
				
				int main()
				{
					function<int(int, int)> f1 = Sub;
					cout << f1(10, 5) << endl;
				
					// 调整参数顺序
					function<int(int, int)> f2 = bind(Sub, placeholders::_2, placeholders::_1);
					cout << f2(10, 5) << endl;
				
					return 0;
				}

使用 bind 调整参数顺序如下图所示：

还可以像以下这种用法，调整参数个数：

				int main()
				{
					function<int(int, int)> f1 = Sub;
					cout << f1(10, 5) << endl;
				
					// 调整参数个数，有些参数可以使用 bind 时固定
					function<int(int)> f3 = bind(Sub, 20, placeholders::_1);
					cout << f3(5) << endl;
				
					return 0;
				}

下面再看一个场景，在类中调用函数指针：

假设有个 Plus 类：

				class Plus
				{
				public:
					static int plusi(int a, int b)
					{
						return a + b;
					}
				
					double plusd(double a, double b)
					{
						return a + b;
					}
				};

我们需要在类外包装类中的成员函数，有以下做法：

				int main()
				{
					// 成员函数取地址，比较特殊，要加一个类域和&
					function<int(int, int)> f1 = &Plus::plusi;
					cout << f1(1, 2) << endl;
					
					// 上面静态成员函数没有 this 指针，所以不用传指针
					// 普通成员函数有 this 指针，所以需要传对象的指针
					function<double(Plus*, double, double)> f2 = &Plus::plusd;
					Plus ps;
					cout << f2(&ps, 1.1, 2.2) << endl;
					
					// 这里传 Plus 编译器会进行特殊处理，实际上是 Plus*
					function<double(Plus, double, double)> f3 = &Plus::plusd;
					cout << f3(Plus(), 1.11, 2.22) << endl;
				
					return 0;
				}

如上对于普通成员函数每一次都要传 Plus*，这时候我们就可以用上面学的 bind 将这个步骤省去，即调整参数的个数，如下：

			function<double(double, double)> f4 = bind(&Plus::plusd, Plus(), placeholders::_1, placeholders::_2);
			cout << f4(1.11, 2.22) << endl;

如上，经过 bind 后，每次使用可调用对象的时候就不需要传 Plus* 了，只需要传参数即可。

四、线程库

1. thread 类的简单介绍

在C++11之前，涉及到多线程问题，都是和平台相关的，比如 windows 和 linux 下各有自己的接口，这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了，使得 C++ 在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库中的线程，必须包 含< thread > 头文件。

当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。线程函数一般情况下可按照以下四种方式提供：

1. 函数指针
2. 仿函数
3. lambda表达式
4. 包装器

如下：

				void ThreadFunc(int a)
				{
					cout << "Thread1" << a << endl;
				}
				
				class TD
				{
				public:
					void operator()()
					{
						cout << "Thread3" << endl;
					}
				};
				
				int main()
				{
					// 线程函数为函数指针
					thread t1(ThreadFunc, 10);
				
					// 线程函数为lambda表达式
					thread t2([]() {
						cout << "Thread2" << endl;
						});
				
					// 线程函数为仿函数
					TD td;
					thread t3(td);
				
					t1.join();
					t2.join();
					t3.join();
				
					cout << "Main thread!" << endl;
				
					return 0;
				}

thread 类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即将一个线程对象关联线程的状态转移给其他线程对象，转移期间不意向线程的执行。所以我们可以使用匿名对象构建一个线程再去构造或者赋值给另一个线程，这种用法配合 vector 使用比较多，一次创建多个空线程对象放入 vector 中，然后再遍历 vector 使用匿名线程给它赋值。

可以通过 jionable() 函数判断线程是否是有效的，如果是以下任意情况，则线程无效：

• 采用无参构造函数构造的线程对象
• 线程对象的状态已经转移给其他线程对象
• 线程已经调用 jion 或者 detach 结束

2. 线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，因此：即使线程参数为引用类型，在线程中修改后也不能修改外部实参，因为其实际引用的是线程栈中的拷贝，而不是外部实参。如果想要通过形参改变外部实参时，必须借助 std::ref() 函数。

3. mutex

在C++11中，mutex 总共包了四个互斥量的种类：

（1）std::mutex

C++11 提供的最基本的互斥量，该类的对象之间不能拷贝，也不能进行移动。mutex 最常用的三个函数：

（2）std::recursive_mutex

其允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。

（3）std::timed_mutex

比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until() ；

• try_lock_for()

接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与 std::mutex 的 try_lock() 不同，try_lock 如果被调用时没有获得锁则直接返回 false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false；

• try_lock_until()

接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false；

（4）std::recursive_timed_mutex

也就是第二和第三的结合。

4. lock_guard

std::lock_gurad 是 C++11 中定义的模板类。定义如下：

				template<class _Mutex>
				class lock_guard
				{
				public:
					// 在构造lock_gard时，_Mtx还没有被上锁
					explicit lock_guard(_Mutex& _Mtx)
						: _MyMutex(_Mtx)
					{
						_MyMutex.lock();
					}
				
					// 在构造lock_gard时，_Mtx已经被上锁，此处不需要再上锁
					lock_guard(_Mutex& _Mtx, adopt_lock_t)
						: _MyMutex(_Mtx)
					{}
				
					~lock_guard() _NOEXCEPT
					{
						_MyMutex.unlock();
					}
				
					lock_guard(const lock_guard&) = delete;
					lock_guard& operator=(const lock_guard&) = delete;
				
				private:
					_Mutex& _MyMutex;
				};

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

5. unique_lock

与 lock_gard 类似，unique_lock 类模板也是采用 RAII 的方式对锁进行了封装，并且也是以独占所有权的方式管理 mutex 对象的上锁和解锁操作，即其对象之间不能发生拷贝。在构造(或移动(move)赋值)时，unique_lock 对象需要传递一个 Mutex 对象作为它的参数，新创建的 unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。使用以上类型互斥量实例化 unique_lock 的对象时，自动调用构造函数上锁，unique_lock 对象销毁时自动调用析构函数解锁，可以很方便的防止死锁问题。

与 lock_guard 不同的是，unique_lock 更加的灵活，提供了更多的成员函数：

• 上锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until 和 unlock
• 修改操作：移动赋值、交换(swap：与另一个unique_lock对象互换所管理的互斥量所有权)、释放(release：返回它所管理的互斥量对象的指针，并释放所有权)
• 获取属性：owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相同)、mutex(返回当前unique_lock所管理的互斥量的指针)。

与 lock_guard 的最大区别在于 unique_lock 可以手动解锁和上锁。

6. 原子性操作库(atomic)

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

				#include <iostream>
				#include <thread>
				
				using namespace std;
				size_t sum = 0;
				
				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, 100000);
					thread t2(fun, 100000);
					t1.join();
					t2.join();
				
					cout << "After joining,sum = " << sum << std::endl;
					return 0;
				}

由于存在线程安全问题，所以运行的结果每次都不一样：

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

在 C++11 中，程序员不需要对原子类型变量进行加锁解锁操作，线程能够对原子类型变量互斥的访问。在C++11中，程序员不需要对原子类型变量进行加锁解锁操作，线程能够对原子类型变量互斥的访问。

更为普遍的，程序员可以使用 atomic 类模板，定义出需要的任意原子类型，例如：atmoic<T> t; ，声明一个类型为 T 的原子类型变量 t.

注意：原子类型通常属于"资源型"数据，多个线程只能访问单个原子类型的拷贝，因此在 C++11 中，原子类型只能从其模板参数中进行构造，不允许原子类型进行拷贝构造、移动构造以及 operator= 等，为了防止意外，标准库已经将 atmoic 模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了。

如下代码：

				#include <iostream>
				#include <thread>
				#include <atomic>
				
				using namespace std;
				atomic<size_t> sum = 0;
				
				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, 100000);
					thread t2(fun, 100000);
					t1.join();
					t2.join();
				
					cout << "After joining,sum = " << sum << std::endl;
					return 0;
				}

7. condition_variable

condition_variable 我们在 线程同步 中介绍过了，他们用来进行线程之间的互相通知。condition_variable 和 Linux posix 的条件变量并没有什么大的区别，主要还是面向对象实现的。条件变量的文档如下：条件变量.

下面我们使用条件变量简单实现一个功能：支持两个线程交替打印，一个打印奇数，一个打印偶数。代码如下：

				#include <thread>
				#include <mutex>
				#include <iostream>
				
				
				int main()
				{
					std::mutex mtx;
					std::condition_variable cv;
					bool flag = false;
				
					std::thread t1([&]() {
						for (size_t num = 1; num <= 1000; num += 2) {
							std::unique_lock<std::mutex> Lock(mtx);
							if (flag) {
								cv.wait(Lock);
							}
							std::cout << num << std::endl;
							flag = true;
				
							cv.notify_one();
						}
						});
				
					std::thread t2([&]() {
						for (size_t num = 2; num <= 1000; num += 2) {
							std::unique_lock<std::mutex> Lock(mtx);
							if (!flag) {
								cv.wait(Lock);
							}
							std::cout << num << std::endl;
							flag = false;
				
							cv.notify_one();
						}
						});
				
					t1.join();
					t2.join();
				
					return 0;
				}