C++11-CSDN博客

本文链接：https://blog.csdn.net/2303_81266461/article/details/139561705

一，完美转发

模板中的&& 万能引用

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值
template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10);// 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);// const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

std::forward 完美转发在传参的过程中保留对象原生类型属性

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t)
{
	Fun(std::forward<T>(t));
}
int main()
{
	PerfectForward(10);           // 右值
	int a;
	PerfectForward(a);            // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b);      // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

二，可变参数模板

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

递归函数方式展开参数包

// 递归终止函数
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;
}

三，lambda表达式

lambda 表达式语法

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

}

lambda 表达式各部分说明

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

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

函数使用

mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)

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

连同 () 一起省略

int main()
{
	// 最简单的lambda表达式, 该lambda表达式没有任何意义
	[] {};

	// 省略参数列表和返回值类型，返回值类型由编译器推导为int
	int 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;

	// 复制捕捉x
	int x = 10;
	auto add_x = [x](int a) mutable { x *= 2; return a + x; };
	cout << add_x(10) << endl;
	return 0;
}

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

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

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

[&var]：表示引用传递捕捉变量var
[this]：表示值传递方式捕捉当前的this指针

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

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

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

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

[& ， a, this] ：值传递方式捕捉变量 a 和 this ，引用方式捕捉其他变量

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

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

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

e. 在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者

非局部变量都会导致编译报错

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

四，包装器

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

常见使用方式

#include <functional>
using func_t = std::function<int(int, int)>;
int add(int x, int y)
{
	return x + y;
}

int main()
{
	int a = 1; int b = 1;
	func_t f = add;
	std::cout<<f(a, b) << std::endl;
	return 0;

}

bind

#include <iostream>
#include <functional>

class A {
public:
    void fun_3(int k,int m) {
        std::cout << "print: k = "<< k << ", m = " << m << std::endl;
    }
};

void fun_1(int x,int y,int z) {
    std::cout << "print: x = " << x << ", y = " << y << ", z = " << z << std::endl;
}

void fun_2(int &a,int &b) {
    ++a;
    ++b;
    std::cout << "print: a = " << a << ", b = " << b << std::endl;
}

int main(int argc, char * argv[]) {
    //f1的类型为 function<void(int, int, int)>
    auto f1 = std::bind(fun_1, 1, 2, 3); 					//表示绑定函数 fun 的第一，二，三个参数值为： 1 2 3
    f1(); 													//print: x=1,y=2,z=3

    auto f2 = std::bind(fun_1, std::placeholders::_1, std::placeholders::_2, 3);
    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f2 的第一，二个参数指定
    f2(1, 2);												//print: x=1,y=2,z=3
 
    auto f3 = std::bind(fun_1, std::placeholders::_2, std::placeholders::_1, 3);
    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f3 的第二，一个参数指定
    //注意： f2  和  f3 的区别。
    f3(1, 2);												//print: x=2,y=1,z=3

    int m = 2;
    int n = 3;
    auto f4 = std::bind(fun_2, std::placeholders::_1, n); //表示绑定fun_2的第二个参数为n, fun_2的第一个参数由调用f4的第一个参数（_1）指定。
    f4(m); 													//print: a=3,b=4
    std::cout << "m = " << m << std::endl;					//m=3  说明：bind对于不事先绑定的参数，通过std::placeholders传递的参数是通过引用传递的,如m
    std::cout << "n = " << n << std::endl;					//n=3  说明：bind对于预先绑定的函数参数是通过值传递的，如n
    
    A a;
    //f5的类型为 function<void(int, int)>
    auto f5 = std::bind(&A::fun_3, &a, std::placeholders::_1, std::placeholders::_2); //使用auto关键字
    f5(10, 20);												//调用a.fun_3(10,20),print: k=10,m=20

    std::function<void(int,int)> fc = std::bind(&A::fun_3, a,std::placeholders::_1,std::placeholders::_2);
    fc(10, 20);   											//调用a.fun_3(10,20) print: k=10,m=20 

    return 0; 
}

五，线程库

在 C++11 之前，涉及到多线程问题，都是和平台相关的，比如 windows 和 linux 下各有自己的接

口，这使得代码的可移植性比较差 。 C++11 中最重要的特性就是对线程进行支持了，使得 C++ 在

并行编程时不需要依赖第三方库 ，而且在原子操作中还引入了原子类的概念。要使用标准库中的

线程，必须包含 < thread > 头文件

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

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

函数指针

lambda表达式

函数对象

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

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

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

采用无参构造函数构造的线程对象
线程对象的状态已经转移给其他线程对象

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

六，原子性操作库(atomic)

C++98中传统的解决方式：可以对共享修改的数据可以加锁保护
虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对 sum++ 时，其他线程就会被阻

塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁

需要使用以上原子操作变量时，必须添加头文件

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

访问

更为普遍的，程序员可以使用 atomic 类模板，定义出需要的任意原子类型

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

原子类型通常属于 " 资源型 " 数据，多个线程只能访问单个原子类型的拷贝，因此在 C++11

中，原子类型只能从其模板参数中进行构造，不允许原子类型进行拷贝构造、移动构造以及

operator= 等，为了防止意外，标准库已经将 atmoic 模板类中的拷贝构造、移动构造、赋值运算

符重载默认删除掉了

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

七，lock_guard与unique_lock

在多线程环境下，如果想要保证某个变量的安全性，只要将其设置成对应的原子类型即可，即高

效又不容易出现死锁问题。但是有些情况下，我们可能需要保证一段代码的安全性，那么就只能

通过锁的方式来进行控制

比如：一个线程对变量 number 进行加一 100 次，另外一个减一 100 次，每次操作加一或者减一之

后，输出 number 的结果，要求： number 最后的值为1

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

上述代码的缺陷： 锁控制不好时，可能会造成死锁 ，最常见的 比如在锁中间代码返回，或者在锁

的范围内抛异常 。因此： C++11 采用 RAII 的方式对锁进行了封装，即 lock_guard 和 unique_lock

mutex 的种类：

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

1. std::mutex

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

的三个函数

lock() 上锁：锁住互斥量

unlock() 解锁：释放对互斥量的所有权

try_lock() 尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞

注意，线程函数调用 lock() 时，可能会发生以下三种情况：

如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁
如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住
如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

线程函数调用try_lock()时，可能会发生以下三种情况：

如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock释放互斥量
如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉
如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

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

std::recursive_timed_mutex

unique_lock

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 所管理的互斥量的指针 )