010-C++11

czxyvX2026-02-23 13:11

C++11

1. C++11简介

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。

C++11增加的语法特性非常篇幅非常多，这里主要介绍实际中比较实用的一些语法。

2. 统一的列表初始化

2.1 {}初始化

在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。

cpp 复制代码 
struct Point
{
	int _x;
	int _y;
};

int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	Point p = { 1, 2 };
	return 0;
}

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

cpp 复制代码 
struct Point
{
	int _x;
	int _y;
};

int main()
{
	int x1 = 1;
	int x2{ 2 };
	int array1[]{ 1, 2, 3, 4, 5 };
	int array2[5]{ 0 };
	Point p{ 1, 2 };

	// C++11中列表初始化也可以适用于new表达式中
	int* pa = new int[4] { 0 };

	return 0;
}

创建对象时也可以使用列表初始化方式调用构造函数初始化。

cpp 复制代码 
class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 1, 1); // old style
	// C++11支持的列表初始化，这里会调用构造函数初始化
	Date d2{ 2022, 1, 2 };
	Date d3 = { 2022, 1, 3 };
	return 0;
}

2.2 std::initializer_list

文档介绍：initializer_list - C++ Reference

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。

cpp 复制代码 
int main()
{
	vector<int> v = { 1,2,3,4 };
	list<int> lt = { 1,2 };
	// 这里{"sort", "排序"}会先初始化构造一个pair对象，然后这两个对象会构造成一个initializer_list传给map
	map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
	// 使用大括号对容器赋值
	v = { 10, 20, 30 };
	return 0;
}

3. 声明

C++11提供了多种简化声明C的方式，尤其是在使用模板时。

3.1 auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型推断。

这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

cpp 复制代码 
int main()
{
    int i = 10;
    auto p = &i;
    auto pf = strcpy;
    cout << typeid(p).name() << endl;
    cout << typeid(pf).name() << endl;

    map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
    //map<string, string>::iterator it = dict.begin();
    auto it = dict.begin();
    cout << typeid(it).name() << endl;

    return 0;
}

3.2 decltype

关键字decltype将变量的类型声明为表达式指定的类型。

cpp 复制代码 
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
    decltype(t1 * t2) ret;
    cout << typeid(ret).name() << endl;
}

int main()
{
    const int x = 1;
    double y = 2.2;
    decltype(x * y) ret; // ret的类型是double
    decltype(&x) p; // p的类型是int*
    cout << typeid(ret).name() << endl;
    cout << typeid(p).name() << endl;
    F(1, 'a');

    return 0;
}

3.3 nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

4. 范围for

在此前的文章中有详细介绍，这里就不再赘述：001-C++入门-CSDN博客

5. 智能指针

关于智能指针的内容较多，后续会通过一篇文章单独介绍。

6. STL的变化

6.1 新容器

上面四个被框起来的容器是新增的容器，其中unordered系列容器之前有过详细介绍：020-C++之unordered容器-CSDN博客

下面两个容器比较简单，且用到的地方较少，这里就不详细介绍。

array（固定大小的数组）：array - C++ Reference

forward_list（单链表）：forward_list - C++ Reference

6.2 新方法

基本每个容器在C++11中都增加了一些方法，如果提供了返回const迭代器的接口，这些接口其实意义不大，因为原来的普通迭代器就已经支持返回const迭代器了，这只是起到了锦上添花的效果。

实际上C++11更新后，更重要的是，容器中增加的新方法最后用的插入接口函数的右值引用版本，如vector的vector::emplace_back - C++ Reference等接口。

这种插入的方法在部分场景下可以提高插入的效率。

关于如何提高的效率，还需要参考下面的右值引用和移动语义，另外emplace接口还涉及模板的可变参数，后面也会介绍。

7. 右值引用和移动语义

7.1 左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

7.1.1 左值和左值引用

可以出现在赋值符号（=）左边的，我们称之为左值，比如变量名。（左值也可以在=右边）

而左值引用就是给左值取别名。

cpp 复制代码 
int main()
{
	// 以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;

	// 以下几个是对上面左值的左值引用，左值引用本身也是左值
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue = *p;
	
	return 0;
}
7.1.2 右值和右值引用

只能出现在赋值符号（=）右边的，我们称之为右值，比如字面常量、表达式返回值、函数非引用返回值。

右值引用就是给右值取别名。

cpp 复制代码 
int main()
{
	double x = 1.1, y = 2.2;

	// 以下几个都是常见的右值
	10;
	x + y;
	fmin(x, y);

	// 以下几个都是对右值的右值引用，右值引用的本身也是左值
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);

	// 这里编译会报错：error C2106: "=": 左操作数必须为左值
	10 = 1;
	x + y = 1;
	fmin(x, y) = 1;

	return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用。

7.2 左值引用和右值引用比较

左值引用总结：

  1. 左值引用只能引用左值，不能引用右值。

  2. 但是const左值引用既可引用左值，也可引用右值。

cpp 复制代码 
int main()
{
	// 左值引用只能引用左值，不能引用右值。
	int a = 10;
    
	int& ra1 = a; // ra为a的别名
	//int& ra2 = 10; // 编译失败，因为10是右值
	
	// const左值引用既可引用左值，也可引用右值。
	const int& ra3 = 10;
	const int& ra4 = a;
	return 0;
}

右值引用总结：

  1. 右值引用只能右值，不能引用左值。

  2. 但是右值引用可以move以后的左值（move后面会介绍）。

cpp 复制代码 
int main()
{
	// 右值引用只能右值，不能引用左值。
	int&& r1 = 10;

	// error C2440: "初始化": 无法从"int"转换为"int &&"
	// message : 无法将左值绑定到右值引用
	int a = 10;
	int&& r2 = a;

	// 右值引用可以引用move以后的左值
	int&& r3 = std::move(a);
	return 0;
}

7.3 左值引用和右值引用的场景和意义

【注意】接下来的测试使用下面自己实现的string：

cpp 复制代码 
namespace my // 为了区别和STL库的string
{
	class string
	{
	public:
		typedef char* iterator;

		iterator begin() { return _str; }
		iterator end() { return _str + _size; }

		string(const char* str = ""):_size(strlen(str)), _capacity(_size)
		{
			// cout << "string(const char* str)" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;
			string tmp(s._str);
			swap(tmp);
		}

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
    
    string to_string(int val)
    {
        string ret;
        if (val == 0) ret = "0";
        while (val)
        {
            int tmp = val % 10;
            ret += '0' + tmp;
            val /= 10;
        }
        reverse(ret.begin(), ret.end());

        return ret;
    }
}

前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？

7.3.1 左值引用的场景

做参数和返回值都可以提高效率，使得无需拷贝一份进行传递。

测试代码：

cpp 复制代码 
void func1(my::string s)
{}

void func2(const my::string& s)
{}

int main()
{
	my::string s1("hello world");
	// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
	func1(s1); // 此处将会打印"string(const string& s) -- 深拷贝"
	func2(s1);

	// string operator+=(char ch) 传值返回存在深拷贝，此处将会打印"string(const string& s) -- 深拷贝"
	// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
	s1 += '!';

	return 0;
}

若为string operator+=(char ch)：

若为string& operator+=(char ch)：

7.3.2 左值引用的短板

如果函数返回的对象是局部变量，此时使用左值引用就会出现问题，因为返回后该变量就不存在了，此时只能使用传值，这样会导致至少一次拷贝构造（有一些旧的编译器有可能两次），这就会降低程序效率。

cpp 复制代码 
int main()
{
	// 在my::string to_string(int val)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

	my::string ret1 = my::to_string(1234);
	my::string ret2 = my::to_string(-1234);
	
	return 0;
}

对于上述代码，两行本来应该都会触发拷贝构造，但是由于VS2022环境下强制进行了返回值优化（RVO），RVO 允许编译器直接在调用方（即 ret1 的位置）构造 to_string 返回的对象，从而避免额外的拷贝。

如果想要看到效果，我们可以使用GCC/Clang编译环境加上-fno-elide-constructors选项，这会关闭 RVO 和 NRVO，使拷贝构造函数被调用。

下面在Ubuntu下使用g++进行编译：

在上面这种情况，由于函数的返回值是临时变量，无法使用引用返回，只能直接返回，这就会导致至少一次的拷贝构造。

7.3.3 右值引用和移动语义解决上述问题

我们可以使用右值引用在my::string中增加移动构造。

cpp 复制代码 
// 移动构造
string(string&& s):_str(nullptr), _size(0), _capacity(0)
{
    cout << "string(string&& s) -- 移动语义" << endl;
    swap(s);
}

// 移动赋值
string& operator=(string&& s)
{
    cout << "string& operator=(string&& s) -- 移动语义" << endl;
    swap(s);
    return *this;
}

移动构造的本质是将参数右值的资源窃取过来，占为己有，此时就无需进行深拷贝。

因为这里右值引用的对象本来就是临时对象，即使不拿走它的资源，在出了作用域后该对象也会被销毁。

此时我们再次运行上面7.3.2的代码：

此时就会调用移动构造，不会发生深拷贝，从而提高效率。

对于移动赋值也是一样的道理。

7.4 右值引用引用左值及其一些更深入的使用场景分析

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。

当需要用右值引用引用一个左值时，可以通过std::move函数将左值转化为右值。

文档介绍：move - C++ Reference

cpp 复制代码 
int main()
{
	my::string s1("hello world");

	// 这里s1是左值，调用的是拷贝构造
	my::string s2(s1);
	cout << s1.c_str();
	
	// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
	// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
	// 资源被转移给了s3，s1被置空了。
	my::string s3(std::move(s1));
	cout << s1.c_str(); // 报错：C26800 使用已移动的 from 对象: s1 (lifetime.1)。

	return 0;
}

在C++11中，STL容器中对于插入接口函数也增加了右值引用版本，如vector的push_back：vector::push_back - C++ Reference

7.5 完美转发

在模板中的&&不代表右值引用，而是万能引用，它既能接收左值又能接收右值。

模板的万能引用只是提供了能够同时接收左值引用和右值引用的能力，但是在后续使用中都退化成了左值。

cpp 复制代码 
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。

文档介绍：forward - C++ Reference

forward的作用是在传参的过程中保留对象原生类型属性。

对于上面的函数模板进行修改：

cpp 复制代码 
void PerfectForward(T&& t)
{
	Fun(std::forward<T>(t));
}

运行：

8. 新的类功能

8.1 默认成员函数

在原来的C++类中，有6个默认成员函数：

  1. 构造函数

  2. 析构函数

  3. 拷贝构造函数

  4. 拷贝赋值重载

  5. 取地址重载

  6. const 取地址重载

默认成员函数就是我们不写编译器会生成一个默认的。

C++11 新增了两个：移动构造函数和移动赋值运算符重载。

针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

  • 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。（移动赋值运算重载也是类似）
  • 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

8.2 类成员的初始化

C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化。

8.3 强制生成默认函数-关键字default

假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。

如：你想要默认生成移动构造，但是已经实现了拷贝构造，此时就可以使用default关键字让它强制生成。

cpp 复制代码 
class A
{
	A(const A& a) 
	{
		// ...
	}
	
	A(A&& a) = default;
	
	// ...
};

8.4 禁止生成默认函数-关键字delete

假设你不想某个默认函数自动生成，则可以使用关键字delete，使用方法和default一致。

cpp 复制代码 
class A
{
	A(const A& a) = delete;
	
	// ...
};

8.5 继承和多态中的final与override关键字

关于这个内容，在之前的多态章节中有详细介绍，这里不再赘述。

009-C++之多态-CSDN博客

9. 可变参数模板

9.1 概念

C++11的新特性可变参数模板允许创建，可以接受可变参数的函数模板和类模板。

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

对于上面的参数包，不支持使用args[i]这样方式获取可变参数，我们需要使用一些方法来获取。

下面介绍两种获取参数包的方法。

9.2 递归方式展开参数包

cpp 复制代码 
// 递归终止函数
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;
}

对于上面的代码，当获取到参数包后，取出第一个参数，然后进行打印，然后再将剩下的参数包递归执行，直到参数包中没有参数。

9.3 逗号表达式+初始化列表展开参数包

cpp 复制代码 
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;
}

对于上面的代码，逗号表达式会从左到右执行，并返回最右边的结果，而(PrintArg(args), 0)...的作用是展开参数包，...是参数包展开操作符，作用是将参数包中的每个元素分别展开到前面的表达式中。

对于上面的第三个例子，展开后，(PrintArg(args), 0)...会变成(PrintArg(1), 0), (PrintArg('A'), 0), (PrintArg("sort"), 0)。

然后再借助初始化列表，初始化列表会先对表达式进行求值，然后返回，如(PrintArg(1), 0)，先执行PrintArg(1)，然后执行0，最后返回0。

9.4 C++11中SLT新增的emplace系列接口

emplace系列的接口，支持模板的可变参数，并且万能引用。那么相对insert和emplace系列接口的优势到底在哪里呢？

emplace接口与普通的插入接口的区别在于，如果传入的对象有多个值，普通接口需要先将这些值构造成一个对象，然后拷贝（或移动构造）到容器中，而emplace接口则是直接构造，无需拷贝或移动，例如：

cpp 复制代码 
class MyClass {
public:
    MyClass(int a, const std::string& b) {
        // 复杂的初始化逻辑
    }
    // 拷贝构造函数（开销大）
    MyClass(const MyClass& other) { /* 深拷贝 */ }
};

std::vector<MyClass> vec;

// 传统方式1：
vec.push_back({42, "test"}); // 先构造成MyClass对象，然后再通过拷贝/移动构造（如果实现了移动构造）添加到vec中

// emplace方式：
vec.emplace_back(42, "test");  // 直接构造，无额外开销

从上面可以看出emplace接口可以节省一次拷贝/移动构造的开销。

10. Lambda表达式

10.1 场景提出

在C++98中，使用sort排序，如果是int、char等类型，可以直接默认或者传入greater<T>()对象，来实现升序/降序的效果。

但是如果是对自定义类型进行排序，那么就需要自己定义比较的规则，单独写一个类，而且有很多时候，这个类只在这个地方能用上，不同的地方需要使用不一样的类，这就非常麻烦。

因此，在C++11语法中出现了Lambda表达式。

10.2 Lambda表达式语法

cpp 复制代码 
[capture-list] (parameters) mutable -> return-type { statement }

  • capture-list\]：捕捉列表，该列表总是出现在lambda函数开始的位置，编译器根据\[\]来判断接下来的代码是否为lambda函数，捕捉列表能捕捉上下文中的变量供lambda函数使用。此处填入的内容描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用： * \[var\]：表示值传递方式捕捉变量var * \[=\]：表示值传递方式捕获所有父作用域中的变量(包括this) * \[\&var\]：表示引用传递捕捉变量var * \[\&\]：表示引用传递捕捉所有父作用域中的变量(包括this) * \[this\]：表示值传递方式捕捉当前的this指针 * 允许填入多个值，但不允许填入重复值，如： * \[=, \&a, \&b\]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量 * \[=, a\]：=已经以值传递方式捕捉了所有变量，捕捉a重复

  • mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
  • -> returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
  • { statement }：函数体，该函数体中除了可以使用传递的参数外，还可以使用捕获的变量。

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

10.3 场景演示

cpp 复制代码 
struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价

	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{
	}
};

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

	return 0;
}

此时对于自定义类型，我们每次排序就无需重新写一个类了。

10.4 函数对象与Lambda表达式

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

cpp 复制代码 
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);

	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;};
	r2(10000, 2);

	return 0;
}

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

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

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

11. 包装器

11.1 function

文档介绍：function - C++ Reference

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

使用方法：

复制代码 
std::function<模板参数（函数类型）> 对象名 = 函数对象/lmabda表达式/...;

先看下面的代码：

cpp 复制代码 
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 f(double i)
{
	return i / 2;
}

struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};

int main()
{
	// 函数名
	cout << useF(f, 11.11) << endl;

	// 函数对象
	cout << useF(Functor(), 11.11) << endl;

	// lamber表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;

	return 0;
}

对于上面的结果我们可以看出，三个useF传入的函数对象的类型都是一摸一样的，但是useF还是实例化了三份（三个static变量地址都不同）。

像这样，对于我们看上去是相同的类型，但是它却实例化出了多份的情况下，就会导致效率的低下。

function就可以很好的解决这个问题。

cpp 复制代码 
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 f(double i)
{
	return i / 2;
}

struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};

int main()
{
	// 函数名
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;

	// 函数对象
	std::function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;

	// lamber表达式
	std::function<double(double)> func3 = [](double d)->double { return d / 4; };
	cout << useF(func3, 11.11) << endl;

	return 0;
}

经过包装器的包装，我们可以看到，最终useF只实例化了一份。

11.2 bind

文档介绍：bind - C++ Reference

bind是一个函数模板，它就像一个函数包装器（适配器），接受一个可调用对象，生成一个新的可调用对象来"适应"原对象的参数列表。

使用方法：

cpp 复制代码 
auto 新的函数对象名 = std::bind(待包装的函数, 参数列表...);

我们可以使用bind绑定其中的一些参数，或是将参数调换位置，如下：

cpp 复制代码 
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， 2
	auto 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;
}

上面的代码中类似于placeholders::_1是占位符，比如：std::function<int(int, int)> func4 = std::bind(&Sub::sub, s, placeholders::_2, placeholders::_1);代表的是，使用func4时传递的参数，第一个参数会被放在placeholders::_1位置上，第二个参数会被放在placeholders::_2位置上，以此类推。也就是说，在执行func4(1, 2)时，实际上是执行了Sub::sub(s, 2, 1)。

12. 线程库

12.1 thread类

文档介绍：thread - C++ Reference

在C++11之前，如果涉及到多线程的程序，由于windows和linux等系统都有自己的一套接口，就使得程序的可移植性较差，C++11提供了线程库，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。

常用接口：

接口 功能
thread() noexcept; 构造一个线程对象，没有关联任何线程函数，即没有启动任何线程。
explicit thread (Fn&& fn, Args&&... args); 构造一个线程对象，并关联线程函数fn(args1, args2, ...)。
id get_id() const noexcept; 获取线程id。
bool joinable() const noexcept; 判断线程是否还在执行，还在执行返回true
void join(); 阻塞等待该线程。
void detach(); 分离线程，允许其独立运行（不阻塞当前线程）。分离后无法再join。
static unsigned hardware_concurrency() noexcept; 静态成员函数，返回硬件支持的并发线程数（通常为CPU核心数）。

另外的thread对象也支持移动构造和移动赋值重载，但是不允许拷贝构造和普通赋值重载。

其中get_id()返回的id是用于标识线程，支持比较和判断，可以作为容器的键值。

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

  • 函数指针
  • lambda表达式
  • 函数对象

演示代码：

cpp 复制代码 
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;
}

这里由于没有加锁，所以会出现打印出来的内容混乱。

12.2 线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的。

如果传入的线程函数的参数为引用类型，直接传递变量将会报错，传递的变量只能以拷贝的方式传入线程。

如果想要传递引用变量，必须借助std::ref()函数，或者如果想要修改外部的变量，可以通过传指针的方式。

cpp 复制代码 
void ThreadFunc1(int& x)
{
	x += 10;
}

void ThreadFunc2(int* x)
{
	*x += 10;
}

int main()
{
	int a = 10;

	// 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际引用的是线程栈中的拷贝
	//thread t1(ThreadFunc1, a); // 报错：C2672 "invoke": 未找到匹配的重载函数
	//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;
}

11.3 mutex

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

  1. std::mutex

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

    函数名 函数功能
    void lock(); 上锁：锁住互斥量
    void unlock(); 解锁：释放对互斥量的所有权
    bool try_lock(); 尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞

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

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

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

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

  2. std::recursive_mutex

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

  3. std::timed_mutex

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

    函数名 函数功能
    template <class Rep, class Period> bool try_lock_for (const chrono::duration<Rep,Period>& rel_time); 接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住，，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。
    template <class Clock, class Duration> bool try_lock_until (const chrono::time_point<Clock,Duration>& abs_time); 接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

  4. std::recursive_timed_mutex

    这个则是结合了上面的std::recursive_mutex和std::timed_mutex锁的功能。

11.4 lock_guard与unique_lock

在多线程环境下，如果想要保证某个变量的安全性，只要将其设置成对应的原子类型即可，即高效又不容易出现死锁问题。但是有些情况下，我们可能需要保证一段代码的安全性，那么就只能通过锁的方式来进行控制。

锁控制不好时，可能会造成死锁，最常见的比如在锁中间代码返回，或者在锁的范围内抛异常。因此：C++11采用RAII的方式对锁进行了封装，即lock_guard和unique_lock。

11.4.1 lock_guard

文档介绍：lock_guard - C++ Reference

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

定义如下：

cpp 复制代码 
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 tag) : _MyMutex(_Mtx)
	{}

	~lock_guard()
	{
		_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对象要被销毁，调用析构函数自动解锁，可以有效避免死锁问题。

lock_guard的缺陷：太单一，用户没有办法对该锁进行控制，因此C++11又提供了unique_lock。

11.4.2 unique_lock

文档介绍：unique_lock - C++ Reference

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

11.5 原子性操作库atomic

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

cpp 复制代码 
unsigned 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, 10000000);
	thread t2(fun, 10000000);

	t1.join();
	t2.join();
	cout << "After joining,sum = " << sum << std::endl;

	return 0;
}

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

cpp 复制代码 
mutex m; // 需要包含mutex头文件
unsigned long sum = 0;

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_bool bool
atomic_char char
atomic_schar signed char
atomic_uchar unsigned char
atomic_int int
atomic_uint unsigned int
atomic_short short
atomic_ushort unsigned short
atomic_long long
atomic_ulong unsigned long
atomic_llong long long
atomic_ullong unsigned long long
atomic_char16_t char16_t
atomic_char32_t char32_t
atomic_wchar_t wchar_t

【注意】使用上面类型必须加头文件atomic

cpp 复制代码 
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, 10000000);
	thread t2(fun, 10000000);

	t1.join();
	t2.join();
	cout << "After joining,sum = " << sum << std::endl;

	return 0;
}

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

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

cpp 复制代码 
atmoic<T> t; // 声明一个类型为T的原子类型变量t

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

11.6 条件变量condition_variable

文档介绍：condition_variable - C++ Reference --- condition_variable - C++ Reference

std::condition_variable 是 C++11 引入的线程同步机制 ，用于实现线程间的条件等待和通知。它通常与 std::mutex 和 std::unique_lock 配合使用，解决多线程编程中的生产者-消费者问题 、线程协调等经典场景。

常用接口:

函数名 函数功能
condition_variable(); 创建一个条件变量对象
void wait (unique_lock<mutex>& lck); 传入已经获取到的互斥锁，阻塞，释放互斥锁，直到收到通知。 通常情况下，该函数通过另一个线程对成员notify_one或成员notify_all的调用来被通知唤醒。但某些实现可能会在没有调用这些函数的情况下产生虚假唤醒调用。因此，使用该函数的用户应当确保其恢复条件得到满足。
template <class Predicate> void wait (unique_lock<mutex>& lck, Predicate pred); 带谓词的wait，所谓谓词，就是一个函数对象/函数指针，只有当被通知唤醒，且pred执行返回true时线程才会被唤醒，这种版本是为了防止虚假唤醒。
template <class Rep, class Period> cv_status wait_for (unique_lock& lck, const chrono::duration<Rep,Period>& rel_time); 超时版wait，如果超过指定时间，自动释放，并执行lck.lock()。
template<typename Rep, typename Period, typename Predicate> bool wait_for(std::unique_lockstd::mutex& lock, const std::chrono::duration<Rep, Period>& rel_time, Predicate pred); 超时版带谓词的wait。
template <class Clock, class Duration> cv_status wait_until (unique_lock& lck, const chrono::time_point<Clock,Duration>& abs_time); 指定时间点wait，通过超过指定时间点，自动释放，并执行lck.lock()。
template <class Clock, class Duration, class Predicate> bool wait_until (unique_lock& lck, const chrono::time_point<Clock,Duration>& abs_time, Predicate pred); 指定时间点带谓词的wait。
void notify_one() noexcept; 唤醒一个阻塞于当前条件变量上的线程。
void notify_all() noexcept; 唤醒所有阻塞于当前条件变量上的线程。

【注意】条件变量的拷贝构造、移动构造、赋值运算符均被删除。

11.7 应用-两个线程交替打印奇偶数

cpp 复制代码 
#include <thread>
#include <mutex>
#include <condition_variable>

void two_thread_print()
{
	std::mutex mtx;
	condition_variable c;
	int n = 20;
	bool flag = true;

	thread t1([&]() {
		int i = 0;
		while (i < n)
		{
			unique_lock<mutex> lock(mtx);
			c.wait(lock, [&]()->bool {return flag; });
			cout << "thread - 1: " << i << endl;
			flag = false;
			i += 2; // 偶数
			c.notify_one();
		}
	});

	thread t2([&]() {
		int j = 1;
		while (j < n)
		{
			unique_lock<mutex> lock(mtx);
			c.wait(lock, [&]()->bool {return !flag; });
			cout << "thread - 2: " << j << endl;
			j += 2; // 奇数
			flag = true;
			c.notify_one();
		}
	});

	t1.join();
	t2.join();
}

int main()
{
	two_thread_print();

	return 0;
}
相关推荐
水饺编程2 小时前
第4章，[标签 Win32] ：TextOut 测试案例2
c语言·c++·windows·visual studio
亓才孓2 小时前
【MyBatis Plus】Wrapper接口
java·开发语言·数据库·spring boot·mybatis
tianzhiyi1989sq2 小时前
C++工具库之PugiXML使用指南
java·数据库·c++
游乐码2 小时前
c#运算符重载
开发语言·c#
人道领域2 小时前
MyBatisPlus高效开发实战指南
java·开发语言·数据库
tankeven2 小时前
HJ98 喜欢切数组的红
c++·算法
游乐码2 小时前
c#继承的原则
开发语言·c#
lsx2024062 小时前
Servlet 文件上传
开发语言
adore.9682 小时前
2.22 oj基础92 93 94+U12
数据结构·c++·算法
热门推荐
01GitHub 镜像站点02AI Agent 平台横评：ZeroClaw vs OpenClaw vs Nanobot03Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services04HTML 早已不是标签了，它现在是系统级接口：这 9 个 API 直接干翻常用 JS 库05全面体验 Grok API 中转站（2025 · Grok 4 系列最新版）06如何解决 OpenClaw “Pairing required” 报错：两种官方解决方案详解07【OpenClaw 本地实战 Ep.3】突破瓶颈：强制修改 openclaw.json 解锁 32k 上下文记忆08MIUI显示/隐藏5G开关的方法，信号弱时开启手机Wifi通话方法09openClaw安装飞书插件｜核心踩坑：spawn EINVAL 错误终极解决指南10配置 OpenClaw 使用 Ollama 本地模型