目录

一、可变参数模板

1.1、可变参数模板的概念

1.2、可变参数模板的定义方式

1.3、如何获取可变参数

二、lambda表达式

2.1、Lamabda表达式定义

2.2、为什么有Lambda

2.3、Lambda表达式的用法

2.4、函数对象与lambda表达式

三、包装器

3.1、function

3.2、bind

四、线程库

4.1、thread类的简单介绍

4.2、线程函数参数

4.3、原子性操作库(atomic)

4.4、lock_guard与unique_lock    

一、可变参数模板

1.1、可变参数模板的概念

可变参数模板是C++11新增的最强大的特性之一，它对参数高度泛化，能够让我们创建可以接受可变参数的函数模板和类模板。

• 在C++11之前，类模板和函数模板中只能包含固定数量的模板参数，可变模板参数无疑是一个巨大的改进，但由于可变参数模板比较抽象，因此使用起来需要一定的技巧。
• 在C++11之前其实也有可变参数的概念，比如printf函数就能够接收任意多个参数，但这是函数参数的可变参数，并不是模板的可变参数。

1.2、可变参数模板的定义方式

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

1.3、如何获取可变参数

方法一、递归函数方式展开参数包

// 递归终止函数
template <class T>
void ShowList(const T& t)
{cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{cout << value <<" ";ShowList(args...);
}
int main()
{ShowList(1);ShowList(1, 'A');ShowList(1, 'A', std::string("sort"));return 0;
}

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

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

cplusplus.com/reference/vector/vector/emplace_back/

cplusplus.com/reference/list/list/emplace_back/

template <class... Args>
void emplace_back (Args&&... args);

int main()
{std::list< std::pair<int, char> > mylist;// emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象// 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别mylist.emplace_back(10, 'a');mylist.emplace_back(20, 'b');mylist.emplace_back(make_pair(30, 'c'));mylist.push_back(make_pair(40, 'd'));mylist.push_back({ 50, 'e' });for (auto e : mylist)cout << e.first << ":" << e.second << endl;return 0;
}

int main()
{// 下面我们试一下带有拷贝构造和移动构造的bit::string，再试试呢// 我们会发现其实差别也不到，emplace_back是直接构造了，push_back// 是先构造，再移动构造，其实也还好。std::list< std::pair<int, bit::string> > mylist;mylist.emplace_back(10, "sort");mylist.emplace_back(make_pair(20, "sort"));mylist.push_back(make_pair(30, "sort"));mylist.push_back({ 40, "sort"});return 0;
}

二、lambda表达式

2.1、Lamabda表达式定义

Lambda 表达式（lambda expression）是一个匿名函数，lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数。

2.2、为什么有Lambda

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

#include <algorithm>
#include <functional>
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;}
};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());
}

2.3、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; });
}

2.4、Lambda表达式语法

1. lambda表达式各部分说明:

[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来

判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda

函数使用。

(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以

连同()一起省略

mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量

性。使用该修饰符时，参数列表不可省略(即使参数为空)。

->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回

值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推 导。

{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获

到的变量。

int main()
{// 最简单的lambda表达式, 该lambda表达式没有任何意义[]{}; // 省略参数列表和返回值类型，返回值类型由编译器推导为intint a = 3, b = 4;[=]{return a + 3; }; // 省略了返回值类型，无返回值类型auto fun1 = [&](int c){b = a + c; }; fun1(10)cout<<a<<" "<<b<<endl;// 各部分都很完善的lambda函数auto fun2 = [=, &b](int c)->int{return b += a+ c; }; cout<<fun2(10)<<endl;// 复制捕捉xint x = 10;auto add_x = [x](int a) mutable { x *= 2; return a + x; }; cout << add_x(10) << endl; return 0;
}

2. 捕获列表说明：

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

[var]：表示值传递方式捕捉变量var

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)

[&var]：表示引用传递捕捉变量var

[&]：表示引用传递捕捉所有父作用域中的变量(包括this)

[this]：表示值传递方式捕捉当前的this指针

void (*PF)();
int main()
{auto f1 = []{cout << "hello world" << endl; };auto f2 = []{cout << "hello world" << endl; };// 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了//f1 = f2;   // 编译失败--->提示找不到operator=()// 允许使用一个lambda表达式拷贝构造一个新的副本auto f3(f2);f3();// 可以将lambda表达式赋值给相同类型的函数指针PF = f2;PF();return 0;
}

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

三、包装器

3.1、function

函数包装器器其实就是函数指针，用了包装器之后，函数模板只会实例化一次，这里我们了解其用法即可。

可调用对象的类型:函数指针、仿函数(函数对象)、lambda

// 函数模板会被实例化多次
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 func(double i)
{return i / 2;
}struct Functor
{double operator()(double d){return d / 3;}
};int main()
{// 函数名cout << useF(func, 11.11) << endl;// 函数对象cout << useF(Functor(), 11.11) << endl;// lamber表达式cout << useF([](double d)->double{ return d / 4; }, 11.11) << endl;return 0;
}

这里我们可以看到静态变量count，每次的地址都不一样，说明函数模板实例化了3次。

我们可以通过包装器只让函数模板实例化一次

int main()
{	// 函数名 生成一个函数包装器，f1就是函数指针 ==  double (*f1)(double)std::function<double(double)> f1 = func;cout << useF(f1, 11.11) << endl;// 函数对象std::function<double(double)> f2 = Functor();cout << useF(f2, 11.11) << endl;// lamber表达式std::function<double(double)> f3 = [](double d)->double{ return d / 4; };cout << useF(f3, 11.11) << endl;return 0;
}

可以看到count的值是累加的，说明函数模板只实例化了一次

3.2、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);

// 使用举例
#include <functional>
int Plus(int a, int b)
{return a + b;
}
class Sub
{
public:int sub(int a, int b){return a - b;}
};
int main()
{//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1, 
placeholders::_2);//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);//func2的类型为 function<void(int, int, int)> 与func1类型一样//表示绑定函数 plus 的第一，二为： 1， 2auto  func2 = std::bind(Plus, 1, 2);   cout << func1(1, 2) << endl;cout << func2() << endl;Sub s;// 绑定成员函数std::function<int(int, int)> func3 = std::bind(&Sub::sub, s, 
placeholders::_1, placeholders::_2);// 参数调换顺序
std::function<int(int, int)> func4 = std::bind(&Sub::sub, s, 
placeholders::_2, placeholders::_1);cout << func3(1, 2) << endl; cout << func4(1, 2) << endl;return 0;
}

总结：

td::function包装各种可调用的对象，统一可调用对象类型，并且指定了参数和返回值类型。
为什么有std:function，因为不包装前可调用类型存在很多问题:
1、函数指针类型太复杂，不方便使用和理解
2、仿函数类型是一个类名，没有指定调用参数和返回值。得去看operator()的实现才能看出来。3、lambda表达式在语法层，看不到类型。底层有类型，基本都是lambda_uuid，也很难看

四、线程库

4.1、thread类的简单介绍

注意：

1. 线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的

状态。

2. 当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程。

#include <thread>
int main()
{std::thread t1;cout << t1.get_id() << endl;return 0;
}

get_id()的返回值类型为id类型，id类型实际为std::thread命名空间下封装的一个类，该类中

包含了一个结构体：

// vs下查看
typedef struct
{ /* thread identifier for Win32 */void *_Hnd; /* Win32 HANDLE */unsigned int _Id;
} _Thrd_imp_t;

3. 当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。

线程函数一般情况下可按照以下三种方式提供：

       1》 函数指针

       2》lambda表达式

       3》 函数对象

#include <iostream>
using namespace std;
#include <thread>
void ThreadFunc(int a)
{cout << "Thread1" << a << endl;
}
class TF
{
public:void operator()(){cout << "Thread3" << endl;}
};
int main()
{// 线程函数为函数指针thread t1(ThreadFunc, 10);// 线程函数为lambda表达式thread t2([]{cout << "Thread2" << endl; });// 线程函数为函数对象TF tf;thread t3(tf);t1.join();t2.join();t3.join();cout << "Main thread!" << endl;return 0;
}

4. thread类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即将一个

线程对象关联线程的状态转移给其他线程对象，转移期间不意向线程的执行。

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

       1> 采用无参构造函数构造的线程对象

       2> 线程对象的状态已经转移给其他线程对象

       3> 线程已经调用jion或者detach结束

4.2、线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，因此：即使线程参数为引用类型，在

线程中修改后也不能修改外部实参，因为其实际引用的是线程栈中的拷贝，而不是外部实参。

#include <thread>
void ThreadFunc1(int& x)
{x += 10;
}
void ThreadFunc2(int* x)
{*x += 10;
}
int main()
{int a = 10;// 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际
引用的是线程栈中的拷贝thread t1(ThreadFunc1, a);t1.join();cout << a << endl;// 如果想要通过形参改变外部实参时，必须借助std::ref()函数thread t2(ThreadFunc1, std::ref(a);t2.join();cout << a << endl;// 地址的拷贝thread t3(ThreadFunc2, &a);t3.join();cout << a << endl;return 0;
}

注意：如果是类成员函数作为线程参数时，必须将this作为线程函数参数。

4.3、原子性操作库(atomic)

多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的，那么没问

题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数

据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦。比如：

#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 <iostream>
using namespace std;
#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引入

的原子操作类型，使得线程间数据的同步变得非常高效。

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

atmoic<T> t;    // 声明一个类型为T的原子类型变量t

#include <atomic>
int main()
{atomic<int> a1(0);//atomic<int> a2(a1);   // 编译失败atomic<int> a2(0);//a2 = a1;               // 编译失败return 0;
}

4.4、lock_guard与unique_lock    

#include <thread>
#include <mutex>
int number = 0;
mutex g_lock;
int ThreadProc1()
{for (int i = 0; i < 100; i++){g_lock.lock();++number;cout << "thread 1 :" << number << endl;g_lock.unlock();}return 0;
}
int ThreadProc2()
{for (int i = 0; i < 100; i++){g_lock.lock();--number;cout << "thread 2 :" << number << endl;g_lock.unlock();}return 0;
}
int main()
{thread t1(ThreadProc1);thread t2(ThreadProc2);t1.join();t2.join();cout << "number:" << number << endl;system("pause");return 0;
}