C++11：新特性一篇拿下！

C++11是C++语言的第二个主要版本，也是自C++98以来最重要的更新。它引入了大量新特性，旨在标准化现有实践并改进C++程序员可用的抽象。这些变化包括从TR1、Boost库、C语言以及一些核心语言特性和库特性的集成。C++11的命名原本是C++0x，预期在2010年之前发布，但最终在2011年8月12日被ISO批准，因此它成为了迄今为止版本间隔最长的一个版本。自C++11以来，C++的更新周期大致为每三年一次。

2：统一的列表初始化

2.1：｛｝初始化

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

struct Point
{
	int _x;
	int _y;
};
int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	Point p1 = { 1, 2 };
	Point p2({ 1,2 });
	return 0;
}

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

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

2.2：std::initializer_list

std::initializer_list的介绍文档：cplusplus.com/reference/initializer_list/initializer_list/https://cplusplus.com/reference/initializer_list/initializer_list/

int main()
{
	// the type of il is an initializer_list
	auto il = { 10, 20, 30 };
	cout << typeid(il).name() << endl;
	return 0;
}

2.3：std::initializer_list使用场景

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

3：声明

3.1：auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

3.2：decltype

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

3.3：nullptr

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

4：范围for

std::vector<int> vec = {1, 2, 3, 4, 5};
for (int num : vec) {
    std::cout << num << std::endl;
}

简洁性：范围for循环提供了一种简洁的方式来遍历容器和数组，无需显式使用迭代器。
通用性：可以用于任何提供前后迭代器的容器，包括标准库容器如std::vector、std::array、std::map、std::set等，以及原生数组。
声明与赋值：在循环头部，可以声明新的变量（其类型由容器中的元素类型决定），并为每个元素赋值。
自动类型推导：使用auto关键字可以自动推导元素的类型，这在遍历具有复杂元素类型的容器时非常有用。
只读迭代：在默认情况下，范围for循环提供的是只读访问，如果需要修改元素，需要使用引用类型。
容器要求：容器必须至少支持.begin()和.end()方法，这些方法返回到容器开始和结束的迭代器。
数组支持：原生数组（例如，使用数组声明int arr[] = {1, 2, 3};）也支持范围for循环，因为它们可以隐式地提供.begin()和.end()。
迭代顺序：范围for循环按照容器中的元素顺序进行迭代，对于关联容器，如std::map，迭代顺序是按照键排序的顺序。
性能：范围for循环的性能通常与使用迭代器的传统for循环相当，因为它在内部使用迭代器。
可读性：由于其简洁性，范围for循环可以提高代码的可读性，使得遍历逻辑更加清晰。
不支持反向迭代：范围for循环不支持直接的反向迭代，如果需要反向遍历，可以使用std::rbegin()和std::rend()。
C++11特性：范围for循环是C++11引入的特性，因此需要使用支持C++11或更高版本的编译器。

5：智能指针

1：为什么需要智能指针

2：内存泄漏

2.1 内存泄漏？危害？

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
{
    // 1.内存申请了忘记释放
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = new int;
    // 2.异常安全问题
    int* p3 = new int[10];
    Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
    delete[] p3;
}

2.2 内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

a：堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

b：系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

2.3 如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。

2. 采用RAII思想或者智能指针来管理资源。

3：智能指针的使用及原理

3.1 RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

1：不需要显式地释放资源。

2：采用这种方式，对象所需的资源在其生命期内始终保持有效。


// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
		cout <<" ~SmartPtr()" << endl;
	}
private:
	T* _ptr;
};

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}

void Func()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(new int);
	cout << div() << endl;
}

int main()
{
	try {
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

3.2 智能指针的原

1：RAII特性

2：模拟指针行为（AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用）

3.3 std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。

auto_ptr的实现原理：管理权转移的思想。

3.4 std::unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝。

3.5 std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr。

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
shared_ptr - C++ Reference (cplusplus.com)https://legacy.cplusplus.com/reference/memory/shared_ptr/?kw=shared_ptr

1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。

2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。

3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；

4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

3.6 std::waek_ptr

1：std::weak_ptr是一种提供对shared_ptr管理的对象的弱引用的智能指针。

2：它不拥有它所观察的shared_ptr管理的对象，因此不会增加引用计数。

3：weak_ptr可以用来解决shared_ptr可能产生的循环引用问题，因为循环引用会导致引用计数永远不为零，从而造成内存泄漏。

5：weak_ptr不能直接访问它观察的对象，但它可以被转换为shared_ptr（如果对象仍然存活）。转换可能会失败，此时会返回一个空的shared_ptr。

3.7 shared_ptr线程安全问题

通过下面的程序我们来测试shared_ptr的线程安全问题。

#include<thread>
#include<mutex>
struct Date
{
	int _year = 0;
	int _month = 0;
	int _day = 0;
};
void SharePtrFunc(shared_ptr<Date>& sp, size_t n, mutex& mtx)
{
	cout << sp.get() << endl;
	for (size_t i = 0; i < n; ++i)
	{
		// 这里智能指针拷贝会++计数，智能指针析构会--计数，这里是线程安全的。
		shared_ptr<Date> copy(sp);
		// 这里智能指针访问管理的资源，不是线程安全的。所以我们看看这些值两个线程++了2n次，但是最终看到的结果，并一定是加了2n
		{
			//unique_lock<mutex> lk(mtx);
			copy->_year++;
			copy->_month++;
			copy->_day++;
		}
	}
}

int main()
{
	shared_ptr<Date> p(new Date);
	cout << p.get() << endl;
	const size_t n = 1000000;
	mutex mtx;
	thread t1(SharePtrFunc, std::ref(p), n, std::ref(mtx));
	thread t2(SharePtrFunc, std::ref(p), n, std::ref(mtx));
	t1.join();
	t2.join();
	cout << p->_year << endl;
	cout << p->_month << endl;
	cout << p->_day << endl;
	cout << p.use_count() << endl;
	return 0;
}
    
当两个线程对同一个非原子变量进行++操作时，如果操作不具备原子性，可能出现的结果情况主要有以下几种：

    正确的累加结果：如果恰好在每个线程执行++操作时没有其他线程介入，那么变量的最终值可能正确反映了所有递增操作的累加结果。

    部分累加：最常见的情况是，一个线程读取了变量的原始值，但在它能够将增加后的值写回内存之前，另一个线程也读取了这个原始值，并将它写回内存。这导致了一个递增操作的结果丢失。

    无累加：在极端情况下，如果两个线程读取了同一个值，并且都还没有写回，那么最终的变量值可能与原始值相同，就像没有进行任何递增操作一样。

    不可预测的中间状态：由于线程调度和内存写入的不确定性，变量可能会处于一个中间状态，这个状态既不是原始值，也不是完全累加后的值。

    数据损坏：在极少数情况下，由于硬件故障或异常的内存访问模式，变量的值可能会损坏，得到一个完全不可预测的值。

    未定义行为（Undefined Behavior）：如果递增操作的中间结果被另一个线程读取，并且基于这个中间结果进行操作，那么程序的行为将是未定义的。

需要注意的是shared_ptr的线程安全分为两方面：

1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。

会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、--是需要加锁的，也就是说引用计数的操作是线程安全的。

2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

3.8 shared_ptr的循环引用

struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

循环引用分析：

1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。

2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。

3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。

4. 也就是说_next析构了，node2就释放了。

5. 也就是说_prev析构了，node1就释放了。

6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

解决方案：

struct ListNode
{
    int _data;
    weak_ptr<ListNode> _prev;
    weak_ptr<ListNode> _next;
    ~ListNode(){ cout << "~ListNode()" << endl; }
};

如果不是new出来的对象如何通过智能指针管理？shared_ptr设计了一个删除器来解决这个问题！

// 仿函数的删除器:当智能指针管理不是 new 出来的对象时就需要到删除器。
template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};

template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};
int main()
{
	//仿函数形式的删除器
	FreeFunc<int> freeFunc;
	std::shared_ptr<int> sp1((int*)malloc(4), freeFunc);
	DeleteArrayFunc<int> deleteArrayFunc;
	std::shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);

	//lambda形式的删除器
	std::shared_ptr<A> sp4(new A[10], [](A* p) {cout << "delete[]" << p << endl; delete[] p; });
	std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p)
		{cout << "close[]" << p << endl; fclose(p); });
	return 0;
}

6：右值引用和移动语义

6.1 左值引用和右值引用

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

1. 左值？左值引用？

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址 + 可以对它赋值，左值可以出现赋值符号的左边，它代表一个可识别的存储位置，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

//左值：它代表一个可识别的存储位置
int main()
{
	// 以下的p、b、c、*p都是左值

	int* p = new int(0);
	int b = 1;
	const int c = 2;

	*p = 1;
	cout << *p << endl;

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

2. 右值？右值引用？

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

右值没有持久的存储位置，不能有具体的内存地址，因此不能对右值使用取地址运算符&。
右值是在赋值操作中只能出现在等号右边的表达式，通常表示临时对象或即将销毁的对象。
右值通常用于表示那些只读一次的值，比如一个字面量或者一个表达式的求值结果。

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 去引用，是不是感觉很神奇，这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

int main()
{
    double x = 1.1, y = 2.2;
    int&& rr1 = 10;
    const double&& rr2 = x + y;
    rr1 = 20;
    rr2 = 5.5; // 报错
    return 0;
}

3. 左值引用与右值引用比较

左值引用总结：

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

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

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以后的左值。

int main()
{
	// 右值引用只能右值，不能引用左值。
	int&& r1 = 10;
	// error C2440: “初始化”: 无法从“int”转换为“int &&”
	// message : 无法将左值绑定到右值引用
	int a = 10;

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

左值引用的使用场景：

做参数和做返回值都可以提高效率。

#include <vector>
#include <algorithm>

void modifyVector(std::vector<int>& vec) {
    // 直接修改传入向量的内容
    for (auto& elem : vec) {
        elem *= 2;  // 将向量中的每个元素值翻倍
    }
}

int main() {
    std::vector<int> myVec = {1, 2, 3, 4, 5};
    modifyVector(myVec);

    // myVec 现在是 {2, 4, 6, 8, 10}
    return 0;
}

左值引用的短板：

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。

// 错误的示例：尝试通过左值引用返回局部变量
int& returnLocalByRef() {
    int localValue = 42;
    return localValue; // 错误：localValue在函数返回后生命周期结束
}

// 正确的示例：通过值返回对象
int returnLocalByValue() {
    int localValue = 42;
    return localValue; // 正确：返回值是局部变量的一个副本
}

为了避免这个问题，C++11引入了返回值优化（Return Value Optimization, RVO）和移动语义，它们可以在不产生额外开销的情况下返回对象。移动语义通过std::move将一个对象的资源转移给另一个对象，而返回值优化确保了返回的大型对象或容器不会被不必要地复制。

举个例子：

#include <iostream>
#include <vector>
#include <memory>

class BigData {
public:
    BigData(std::vector<int> data) : data_(std::move(data)) {
        std::cout << "BigData constructed.\n";
    }

    // 移动构造函数
    BigData(BigData&& other) noexcept
        : data_(std::move(other.data_)) {
        std::cout << "BigData moved.\n";
    }

    // 为了完整，提供一些成员函数和变量
    void addData(int value) { data_.push_back(value); }
    const std::vector<int>& getData() const { return data_; }

private:
    std::vector<int> data_;
};

BigData createBigData() {
    std::vector<int> localData = {1, 2, 3, 4, 5};
    // 使用std::move将localData转换为右值，避免在返回时复制
    return std::move(BigData(localData));
}

int main() {
    BigData data = createBigData();
    return 0;
}

右值引用和移动语义解决左值短板：

移动构造本质是将参数右值的资源转移过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是转移别人的资源来构造自己。

// s1.swap(s2)
void swap(string& s)
{
	::swap(_str, s._str);
	::swap(_size, s._size);
	::swap(_capacity, s._capacity);
}

// 移动构造
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;
}

STL中的容器都是增加了移动构造和移动赋值，这也是STL提高效率的一种手段！

4. 右左值引用及场景分析

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。


int main() {
	int a = 10;
	int& ra = a;

	int&& rra = move(ra);
	cout << ra << endl;//10
	cout << rra << endl;//10
	return 0;
}

5. 完美转发

模板中的&& 万能引用


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

7：类的新功能

7.1 默认成员函数

6个默认成员函数

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

1. 构造函数

2. 析构函数

3. 拷贝构造函数

4. 拷贝赋值重载

5. 取地址重载

6. const 取地址重载

最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：移动构造函数和移动赋值运算符重载。

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

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

b：如果你没有自己实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)

c：如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

C++入门篇：类与对象重点解析（中篇）-CSDN博客https://blog.csdn.net/MaoRuofeng/article/details/136086175

7.2 类成员的初始化

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

C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。

class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p)
		:_name(p._name)
		, _age(p._age)
	{}
	Person(Person&& p) = default;
private:
	string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	return 0;
}

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

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

Person(Person&& p) = delete;

8：可变参数模板

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

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些特殊方式来一一获取参数包的值：

递归函数方式展开参数包

逗号表达式展开参数包

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

expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包

8.1 emplace系列接口

在C++中，emplace系列接口是标准库容器（如std::vector、std::map、std::set等）提供的一种就地构造元素的方法。使用emplace可以避免对象的不必要复制或移动，从而提高效率。

在std::vector中，emplace_back用于在容器尾部就地构造一个新元素，而不需要先构造一个临时对象。

#include <vector>

std::vector<std::string> v;
v.emplace_back("Hello, World!"); // 在vector尾部就地构造一个字符串

emplace方法非常有用，尤其是在你需要插入复杂对象或避免额外复制的时候。使用emplace可以确保对象直接在容器中构造，从而提高性能。此外，emplace还可以减少对临时对象的依赖，有助于编写更清晰和更高效的代码。

9：lambda表达式

9.1 lambda表达式语法

1：lambda表达式书写格式：

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

2：lambda表达式各部分说明

[capture-list] :

捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。

(parameters)：

参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略

mutable：

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

->returntype：

返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

{statement}：

函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：

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

9.2 捕获列表说明

捕捉列表描述了上下文中那些数据可以被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函数捕捉列表必须为空。

#include <iostream>
#include <functional>

int main() {
    // 定义一个全局变量
    int globalVar = 42;

    // 块作用域
    {
        int localVar = 10;

        // 在块作用域内，lambda可以捕获局部变量
        auto lambdaInScope = [localVar]() {
            std::cout << "Lambda in scope captures localVar: " << localVar << std::endl;
        };
    }

    // 块作用域外，不能捕获localVar，因为它的生命周期已结束
    // auto lambdaOutOfScope = [localVar]() { }; // 错误：localVar已无效

    // 定义一个lambda，其捕获列表为空，但可以使用全局变量
    auto lambdaOutOfScope = [] {
        std::cout << "Lambda out of scope uses globalVar: " << globalVar << std::endl;
    };

    // 调用块作用域外的lambda
    lambdaOutOfScope();

    return 0;
}

e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。

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

9.3 函数对象与lambda表达式

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


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作为其成员变量，在定义对象时给出初始值即可。ambda表达式通过捕获列表可以直接将该变量捕获到。

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

10：包装器

1：function包装器

模板参数说明：

Ret: 被调用函数的返回类型。

Args…：被调用函数的形参。

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

// 一个简单的函数
int add(int a, int b) {
	return a + b;
}

int main() {
	// 使用std::function包装一个函数
	std::function<int(int, int)> func = add;

	// 调用包装的函数
	std::cout << "Result of add: " << func(1, 2) << std::endl;

	// 使用lambda表达式作为参数
	std::function<void()> lambdaFunc = []() {
		std::cout << "Hello, World!" << std::endl;
		};

	// 调用包装的lambda表达式
	lambdaFunc();

	// 使用std::function作为算法的参数
	std::vector<int> nums = { 1, 2, 3, 4, 5 };
	auto doubleFunc = [](int x) { return 2 * x; };
	std::transform(nums.begin(), nums.end(), nums.begin(), std::function<int(int)>(doubleFunc));

	// 输出变换后的元素
	for (int num : nums) {
		std::cout << num << " ";
	}
	std::cout << std::endl;

	return 0;
}

2：bind

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

可以将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为第二个参数，以此类推:

// 使用举例
#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， 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;
}

11：线程库

11.1 thread类的简单介绍

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

函数名	功能
thread()	构造一个线程对象，没有关联任何线程函数，即没有启动任何线程
thread(fn, args1, args2, ...)	构造一个线程对象，并关联线程函数fn，args1，args2，...为线程函数的参数
get_id()	获取线程id
jionable()	线程是否还在执行，joinable代表的是一个正在执行中的线程。
jion()	该函数调用后会阻塞住线程，当该线程结束后，主线程继续执行
detach()	在创建线程对象后马上调用，用于把被创建线程与线程对象分离开，分离的线程变为后台线程，创建的线程的"死活"就与主线程无关

注意：

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

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

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

A：函数指针

B：lambda表达式

C：函数对象

#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()函数判断线程是否是有效的，如果是以下任意情况，则线程无效。

a：采用无参构造函数构造的线程对象。

b：线程对象的状态已经转移给其他线程对象。

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

面试题：并发和并行的区别？

并发（Concurrency）：
- 并发是指在计算机系统中，多个任务在宏观上同时执行，但在微观上可能是交替执行的。
- 并发强调的是任务的调度和切换，它涉及到操作系统在多个任务之间进行上下文切换，使得从用户的角度看起来像是多个任务同时进行。
- 并发可以在单核处理器上实现，通过时间分片技术让多个任务快速交替执行。
- 并发编程需要处理任务同步、互斥锁、死锁等问题。
并行（Parallelism）：
- 并行是指在计算机系统中，多个任务或操作在同一时刻真正地同时执行。
- 并行需要硬件支持，如多核处理器、多处理器或分布式计算系统，每个处理器核心可以独立执行任务。
- 并行可以显著提高计算性能，特别是在处理可以分解为多个独立且可以并行处理的任务时。
- 并行编程需要考虑数据分解、任务分配、通信和同步等问题。

11.2 线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，因此：即使线程参数为引用类型，在线程中修改后也不能修改外部实参，因为其实际引用的是线程栈中的拷贝，而不是外部实参。

注意：

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

bind:

#include <iostream>
#include <thread>
#include <functional>

class MyClass {
public:
	void memberFunction() {
		std::cout << "Thread ID: " << std::this_thread::get_id()
			<< ", Member function called." << std::endl;
	}
};

void threadFunction(MyClass& obj) {
	obj.memberFunction();
}

int main() {
	MyClass myObject;
	std::thread t(std::bind(threadFunction, std::ref(myObject)));

	t.join(); // 等待线程结束

	return 0;
}

lambda:

#include <iostream>
#include <thread>

class MyClass {
public:
    void memberFunction() {
        std::cout << "Thread ID: " << std::this_thread::get_id()
                  << ", Member function called." << std::endl;
    }
};

int main() {
    MyClass myObject;
    std::thread t([ &myObject ]() {
        myObject.memberFunction();
    });

    t.join(); // 等待线程结束

    return 0;
}

11.3 原子性操作库(atomic)

多线程最主要的问题是共享数据带来的问题(即线程安全)。

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引入的原子操作类型，使得线程间数据的同步变得非常高效。

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

11.4 lock_guard与unique_lock

在多线程环境下，如果想要保证某个变量的安全性，只要将其设置成对应的原子类型即可，即高效又不容易出现死锁问题。但是有些情况下，我们可能需要保证一段代码的安全性，那么就只能通过锁的方式来进行控制。但是，锁控制不好时，可能会造成死锁，最常见的比如在锁中间代码返回，或者在锁的范围内抛异常。
因此：C++11采用RAII的方式对锁进行了封装，即lock_guard和unique_lock。

11.5. mutex的种类

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

1. std::mutex

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

mutex最常用的三个函数：

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

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

a：如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。

b：如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。

c：如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

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

a：如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock释放互斥量。

b：如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。

c：如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

死锁产生的四个必要的条件？互斥，不可剥夺，请求与保持，环路等待

2. std::recursive_mutex

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

3. std::timed_mutex

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

1：try_lock_for()

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

2：try_lock_until()

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

11.6 lock_guard

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

lock_guard的缺陷：

用户没有办法对该锁进行控制(其实我们也可以自己手搓)，因此C++11又提供unique_lock。

11.7 unique_guard

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