---

C++11

1. 模版的可变参数

C++11支持模版的可变参数，可变模版参数比较抽象晦涩，我们只探讨其中基础。

template <class ...Args> // 模版参数包
void ShowList(Args... args) // 函数参数包
{}

...表明是可变模版参数，称为参数包，可以有 $[0,N]$ 个模版参数。可变参数的模版函数，同样是根据调用情况，实例化出多份。

// 展示参数包个数
cout << sizeof...(Args) << endl;
cout << sizeof...(args) << endl;

1.1 模版参数包的使用

void showlist()
{cout << endl;
}template<class T, class... Args>
void show_list(const T& val, Args... args)
{cout << val << " "; // 使用第一个参数showlist(args...); // 向下递归传递参数包
}int main()
{showlist();showlist('1');showlist('1', 2);showlist('1', 2, "string");return 0;
}

参数包可以递归解析。

1. 首先无参调用可直接调用无参版本。
2. 其次有参调用的第一个参数会被val获取，之后的参数会被参数包获取。
3. 使用完第一个参数后，可以传参数包下去递归调用。

打印剩余的参数：

void showlist()
{cout << endl;
}template<class T, class...Args>
void showlist (const T& val, Args... args)
{cout << __FUNCTION__ <<"-->" << sizeof...(args)<<endl;//cout << val << " ";showlist(args...);//cout << sizeof...(args) << endl;//计算大小//如何解析出可变参数包呢？//不能这么玩，语法不支持//for (int i = 0; i < sizeof...(args); i++)//{//	cout << args[i] << " ";//}
}int main()
{showlist('x', 1,2,"string");return 0;
}

线程库就是使用可变模版参数，支持传递任意个参数。 

2. lambda表达式

2.1 Lambda表达式语法

[capture-list](parameters) mutable -> return-type { statement }

语法组成	解释	是否省略
[capture_list]	捕获列表，捕捉当前作用域中的变量。分为传值捕捉和引用捕捉	不可省略
(param_list)	参数列表，形参默认具有const属性，可加mutable去除常属性	可省略
-> ret_type	指明返回类型	可省略自动推导
{}	函数体内容	不可省略

各部分说明:

1. capture-list: 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据来。判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
2. (parameters): 参数列表与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
3. mutable: 默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
4. -> return-type: 返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回0值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
5. { statement }: 函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意:

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为:0;该lambda函数不能做任何事情。

看个样例代码：

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

通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调 用，如果想要直接调用，可借助auto将其赋值给一个变量。

捕获列表说明

[captrue_list] 捕获列表，用来捕捉当前作用域前和全局的变量。[]不可省略。

• 分为传值捕捉和引用捕捉，引用捕捉[&a, &b]。
• [&]表示全引用捕捉，[=]表示全传值捕捉。捕捉所有能捕捉的变量。
• [&a, =]表示混合捕捉，引用捕捉a变量，其他变量传值捕捉。但不可重复捕捉。
• 捕捉列表和参数列表的变量默认用const修饰，可加mutable解除修饰。

auto func1 = [a, b] () {};   // 传值捕捉
auto func2 = [&a, &b] () {}; // 引用捕捉
auto func3 = [=] () {}; // 全传值捕捉
auto func4 = [&] () {}; // 全引用捕捉// 混合捕捉
[&a, &b, =](){}; // 引用捕捉a和b变量，其他变量传值捕捉
[=, a](){}; // 重复传值捕捉a，编译报错

注意：

• 父作用域指包含lambda函数的语句块

• 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

​ 比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量 [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

//Lambda表达式捕捉列表的示例
auto lambda1 = [=, &b]() {std::cout << "Inside lambda1: a = " << a << ", b = " << b << std::endl;// 可以访问变量a的值，但只能以值传递的方式访问，而变量b可以以引用传递的方式访问
};

• 捕捉列表不允许变量重复传递，否则就会导致编译错误。

​ 比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

//Lambda表达式捕捉列表中不允许变量重复传递的示例
/// 以下代码将导致编译错误，因为变量a已经在捕捉列表中以值传递的方式捕捉了
// auto lambda2 = [=, a]() {}; // 编译错误：重复的捕捉变量'a'
// auto lambda3 = [=, &]() {}; //编译错误：传值和引用不可以同时存在

• 在块作用域以外的lambda函数捕捉列表必须为空。

  // 在块作用域以外的lambda函数捕捉列表必须为空的示例
  int c = 20;
  auto lambda3 = [=]() {
  // 在此lambda函数中只能访问到变量a和b，无法访问外部的变量cstd::cout << "Inside lambda3: a = " << a << ", b = " << b << std::endl;
  };
  

• lambda表达式之间不能相互赋值，即使看起来类型相同

  // lambda表达式之间不能相互赋值的示例   
  // auto lambda4 = lambda3; 
  // 编译错误：无法从lambda函数'lambda3'初始化lambda函数'lambda4'
  

2.2 lambda的底层

lambda表达式不能相互赋值，即使看起来类型相同。

auto lamdba = []() {};
cout << sizeof(lamdba) << endl;        // 1
cout << typeid(lamdba).name() << endl; // class `int __cdecl main(void)'::`2'::<lambda_1>// class <lambda_fcbffd5ae4b5ac20353abe92769a204f>

lambda表达式最后会被编译器处理成仿函数，所以lambda是个空类，大小为1。类名不同编译器实现不同，但能保证每个lambda表达式类名不同。

看看仿函数和lambda表达式的底层:

 

3. 包装器

包装器用来包装具有相同特征用途的多个可调用对象，便于以统一的形式调用它们。

3.1 function包装器

function包装器也叫做适配器，C++中的function本质是一个类模版。定义如下：

#include <functional>template <class RetType, class... ArgsType> /* 声明返回类型和参数类型 */class function<Ret(Args...)>; 

// 普通函数
int func(int a, int b) { return a + b; }	
// 仿函数
struct functor {int operator()(int x, int y) { return x + y; }
};
// 非静态成员函数
struct Plus {int plus(int a, int b) { return a + b; }
};
// 静态成员函数
struct Sub {static int sub(int a, int b) { return a - b; }
};std::function<int(int, int)>          f1 = f;
std::function<int(int, int)>          f2 = Functor();
std::function<int(Plus&, int, int)>   f3 = &Plus::plus;
std::function<int(int, int)>          f4 = Sub::sub;

封装成员函数时需要注意的点有：指定类域、对象参数、加取地址符。

struct Plus {Plus(int i) {}int plus(int a, int b) { return a + b; }
};int main()
{function<int(Plus, int, int)> f1 = &Plus::plus;f1(Plus(1), 1, 2);function<int(Plus&, int, int)> f2 = &Plus::plus;Plus p(1);f2(p, 1, 2);function<int(Plus*, int, int)> f3 = &Plus::plus;f3(&p, 1, 2);function<int(Plus&&, int, int)> f4 = &Plus::plus;f4(Plus(3), 1, 2);return 0;
}

3.2 bind

bind函数也是一个函数包装器，本质是一个函数模版。生成一个新的可调用对象，来调整一个可调用对象的参数列表。

// without return 
template <class Func, class... Args>bind(Func&& fn, Args&&... args);// with return type
template <class Ret, class Func, class... Args>  bind(Func&& fn, Args&&... args);

class suber
{
public:suber(int rt) : _rt(rt){}int sub(int a, int b) { return (a - b) * _rt; }
private:int _rt;
};// 通过bind调整参数顺序
function<int(int, int)> f1 = bind(suber, placeholders::_1, placeholders::_2);
function<int(int, int)> f2 = bind(suber, placeholders::_2, placeholders::_1);
cout << f1(2, 1) << endl;
cout << f2(1, 2) << endl;// 通过bind调整参数个数
function<int(suber, int, int)> f3 = &Sub::sub;
function<int(int, int)> f4 = bind(&Sub::sub, Sub(3), placeholders::_1, placeholders::_2);
cout << f3(Sub(1), 2, 1) << endl;
cout << f4(2, 1) << endl;

 

4. 线程库

C++11提供了跨平台的具有面向对象特性的线程库，线程相关的系统知识在此不作赘述，直接讨论线程库的使用。

4.1 thread类

构造函数	解释
thread() noexcept	创建thread对象，不执行任何操作
thread(Fn&& fn, Args&&... args)	传入调用对象和参数列表
thread(const thread&) = delete	线程对象不可拷贝
thread(thread&& th)	线程对象支持移动
成员函数	解释
void join()	等待线程
void detach()	分离线程

关于当前线程的一些操作被放到this_thread类中：

this_thread 成员函数	解释
thread::id get_id () noexcept	返回线程ID
void sleep_for (const chrono::duration<Rep,Period>& rel_time)	设置休眠时间

vector<thread> thds(N); // 线程池
atomic<int> x = 0;for (auto& td : thds) {td = thread([&x, M](int i = 0) { while (i++ < M) {cout << this_thread::get_id() << "->" << x << endl; // get_id()this_thread::sleep_for(std::chrono::seconds(1));    // sleep_for()x++;}});
}for (auto& td : thds) {td.join();
}

4.2 mutex类

mutex类封装系统中的互斥锁，具体接口如下：

mutex	解释
mutex() noexcept	创建互斥锁
mutex (const mutex&) = delete	禁止拷贝锁
void lock()	加锁
void unlock()	解锁
lock_guard	解释
explicit lock_guard (mutex_type& m)	构造函数
lock_guard (const lock_guard&) = delete	不支持拷贝
unique_lock	解释
explicit unique_lock (mutex_type& m)	构造函数
unique_lock (const unique_lock&) = delete	不支持拷贝
void lock()	加锁
void unlock()	解锁

捕获异常并解锁释放资源是不够友好的，因此异常时资源的处理，交给RAII解决。RAII即资源获取就是初始化，是一种管理资源的用法。

本质是将资源封装成类，自动调用构造和析构。以达到资源获取自动初始化，出作用域自动释放的效果。

利用 RAII 封装的成“智能锁”，我们称之为锁守卫lock_guard。

4.3 atomic类

保证自增减的原子性，可以使用原子操作。atomic类封装系统原子操作，具体接口如下：

template <class T> struct atomic;T fetch_add (T val, memory_order sync = memory_order_seq_cst) volatile noexcept; // +=
T fetch_sub (T val, memory_order sync = memory_order_seq_cst) volatile noexcept; // -=
T fetch_and (T val, memory_order sync = memory_order_seq_cst) volatile noexcept; // &=
T fetch_or  (T val, memory_order sync = memory_order_seq_cst) volatile noexcept; // |=
T fetch_xor (T val, memory_order sync = memory_order_seq_cst) volatile noexcept; // ^=
T operator++() volatile noexcept; // ++
T operator--() volatile noexcept; // --

无锁算法CAS

Linux原子操作系统调用

4.4 condition_variable类

条件变量是线程同步的一种机制，主要包括两个动作：等待条件变量挂起，条件变量成立运行。

condition_variable	解释
condition_variable()	构造条件变量
condition_variable (const condition_variable&) = delete	禁止拷贝条件变量
void wait (unique_lock<mutex>& lck)	直接等待
void wait (unique_lock<mutex>& lck, Predicate pred)	指定条件下等待
void notify_one() noexcept	唤醒单个线程
void notify_all() noexcept	唤醒多个线程

// wait的实现
template <class Predicate>  
void wait (unique_lock<mutex>& lck, Predicate pred)
{while (!pred()) /* pred()为假，进入等待 */wait(lck);
}

tex>& lck) | 直接等待 | |void wait (unique_lock& lck, Predicate pred) | 指定条件下等待 | |void notify_one() noexcept | 唤醒单个线程 | |void notify_all() noexcept` | 唤醒多个线程 |

// wait的实现
template <class Predicate>  
void wait (unique_lock<mutex>& lck, Predicate pred)
{while (!pred()) /* pred()为假，进入等待 */wait(lck);
}

模版参数pred是个可调用对象，其返回值代表线程是否进入临界区的条件。条件为真停止等待，条件为假进入等待。