构建安全的C++内存管理体系：从RAII到智能指针的完整解决方案

🔥个人主页：胡萝卜3.0****

📖个人专栏：************************************************************************************************************************************************************************************************************************************************************《C语言》、《数据结构》 、《C++干货分享》、LeetCode&牛客代码强化刷题****************************************************************************************************************************************************************************************************************************************************************

《Linux系统编程》

⭐️人生格言：不试试怎么知道自己行不行

---

🎥胡萝卜3.0🌸的简介：

---

---

目录

前沿：

一、智能指针的使用场景分析

二、RAII和智能指针的设计思路

三、C++标准库智能指针的使用

[3.1 auto_ptr](#3.1 auto_ptr)

[3.2 unique_ptr](#3.2 unique_ptr)

[3.3 shared_ptr](#3.3 shared_ptr)

四、智能指针的原理以及模拟实现shared_ptr

[4.1 auto_ptr和unique_ptr模拟实现](#4.1 auto_ptr和unique_ptr模拟实现)

[4.2 shared_ptr模拟实现（面试手撕）](#4.2 shared_ptr模拟实现（面试手撕）)

五、删除器

shared_ptr模拟实现完整代码（含删除器以及相应改进）

[shared_ptr和unique_ptr都特化了new[ ]](#shared_ptr和unique_ptr都特化了new[ ])

六、make_shared

七、shared_ptr和weak_ptr

[7.1 shared_ptr循环引用问题](#7.1 shared_ptr循环引用问题)

[7.2 weak_ptr](#7.2 weak_ptr)

八、shared_ptr的线程安全问题

[8.1 说明](#8.1 说明)

[8.2 理论](#8.2 理论)

[8.3 保证线程安全的shared_ptr完整代码](#8.3 保证线程安全的shared_ptr完整代码)

[九、 历史发展：C++11和boost中智能指针的关系](#九、 历史发展：C++11和boost中智能指针的关系)

十、内存泄漏问题

[10.1 什么是内存泄漏，内存泄漏的危害](#10.1 什么是内存泄漏，内存泄漏的危害)

[10.1.1 理论：什么是内存泄漏？](#10.1.1 理论：什么是内存泄漏？)

[10.2 如何检测内存泄漏（了解一下）](#10.2 如何检测内存泄漏（了解一下）)

[10.3 如何避免内存泄漏](#10.3 如何避免内存泄漏)

结尾

---

前沿：

在C++中没有垃圾回收，所谓的垃圾回收就是指我们动态申请的资源，我们需要手动地进行释放，就比如：new了一个对象后，我们需要手动的释放，但是有时候，虽然我们进行了手动的释放，但是在delete之前遇到了异常，此时需要抛出异常，异常抛出之后，throw后面的语句不再执行，这就会导致我们申请的空间没有得到释放，从而导致内存泄露，这是很危险的，所以我们要借助智能指针来帮助我们自动的释放动态申请的资源~~~

一、智能指针的使用场景分析

double Divide(int a, int b)
{
	// 当b == 0时抛出异常 
	if (b == 0)
	{
		throw "Divide by zero condition!";
	}
	else
	{
		return (double)a / (double)b;
	}
}
void Func()
{
	// 这⾥可以看到如果发⽣除0错误抛出异常，另外下⾯的array和array2没有得到释放。 
	// 所以这⾥捕获异常后并不处理异常，异常还是交给外⾯处理，这⾥捕获了再重新抛出去。 
	// 但是如果array2new的时候抛异常呢，就还需要套⼀层捕获释放逻辑，这⾥更好解决⽅案 
	// 是智能指针，否则代码太戳了 
	int* array1 = new int[10];
	int* array2 = new int[10]; // 抛异常呢 
	try
	{
		int len, time;
		cin >> len >> time;
		cout << Divide(len, time) << endl;
	}
	catch (...)
	{
		cout << "delete []" << array1 << endl;
		cout << "delete []" << array2 << endl;
		delete[] array1;
		delete[] array2;
		throw; // 异常重新抛出，捕获到什么抛出什么 
	}
	// ...
	cout << "delete []" << array1 << endl;
	delete[] array1;
	cout << "delete []" << array2 << endl;
	delete[] array2;
}
int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}
	return 0;
}

从上面的程序中我们可以看到，new了以后，我们也delete了，但是因为抛异常就导致后面的delete没有得到执行，所以就导致内存泄露了，所以我们需要new以后捕获异常，捕获到异常后delete资源，再把异常抛出来，但是因为new本省也可能抛异常，连续的两个new和下面的Divide都有可能会抛出异常，这就让我们处理起来很麻烦。

但是，如果我们将智能指针放到这种场景中就会让问题变得很简单~~~

ok，那接下来，让我们一探智能指针的庐山真面目~~~

在学习智能指针之前，我们先来了解一下智能指针的设计思路（面试中也会被问的哦）

二、RAII和智能指针的设计思路

RAII是Resource Acquisition Is Initialization的缩写（请求资源立即初始化）

他是一种管理资源的类的设计思想，本质是一种利用对象生命周期来管理获取到的动态资源，从而避免资源泄露（这里的资源可以是内存、文件指针、网络连接、互斥锁等），也就是说：需要手动申请，需要手动释放的东西都可以通过RAII设计的东西来管理。

RAII在获取资源的时候把资源委托给一个对象，接着通过这个对象来控制对资源的访问，资源在对象的生命周期内始终保持有效，最后在对象析构的时候对资源进行释放，这样就保证了资源的正常释放，从而避免资源泄露的问题！

有点不太明白！

简单来说就是：

我们获取资源的时候别自己管，初始化就是构造，立即构造给一个对象，委托给一个对象，交给这个对象进行管理。

为什么交给一个对象进行管理就没问题呢？

因为对象的释放是自动的，这个对象只要正常释放就一定会析构，只要我们在这个对象的析构函数里面对动态申请的资源进行释放，这样我们就可以避免资源泄露的问题

ok，我们通过代码来看一下------

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete _ptr;
	}
private:
	T* _ptr;//因为我们申请的资源都是放在一个指针里面的
};
int main()
{
	SmartPtr<int> sp1 = new int(2);
	return 0;
}

ok，那接下来，我们来看看怎么用这个来解决上面的问题：

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete[] _ptr;
	}
private:
	T* _ptr;//因为我们申请的资源都是放在一个指针里面的
};
double Divide(int a, int b)
{
	// 当b == 0时抛出异常 
	if (b == 0)
	{
		throw "Divide by zero condition!";
	}
	else
	{
		return (double)a / (double)b;
	}
}
void Func()
{ 
	SmartPtr<int> sp1= new int[10];
	SmartPtr<int> sp2 = new int[10];

	int len, time;
	cin >> len >> time;
	cout << Divide(len, time) << endl;
}
int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}
	return 0;
}

ok，也就是说这里无论是抛异常还是不抛异常，我们的资源是交给对象管理的，对象都会正常析构，对象会析构就回去调析构函数，会去调析构函数就会去释放资源

注意：

这里的RAII ！= 智能指针，RAII还可以设计出其他的东西，比如：锁......

• 智能指针类除了满足RAII的设计思路，还要方便进行资源的访问，所以智能指针类还会像迭代器一样，重载operator*/operator->/operator[ ] 等运算符，方便访问资源

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete[] _ptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	T& operator[](size_t i)
	{
		return _ptr[i];
	}
private:
	T* _ptr;//因为我们申请的资源都是放在一个指针里面的
};
int main()
{
	SmartPtr<int> sp1 = new int[5] {1,2,3,4,5};
	SmartPtr<pair<string, int>> sp2 = new pair<string, int>[3] { { "string", 1 }, { "sort",2 }};

	cout << sp1[2] << endl;
	cout << *sp1 << endl;
	cout << sp2->first << endl;
	cout << sp2[1].first << endl;
	return 0;
}

运行一下------

那这时候，就有uu想问了，这个智能指针是需要我们自己手动写的吗？

ok，特殊情况下，如果库中没有，则需要我们自己写，但是一般情况下，我们用库中的即可------

三、C++标准库智能指针的使用

C++标准库中的智能指针都是在<memory>这个头文件下面，我们包含<memory>就可以使用了，库中的智能指针有好几种，除了weak_ptr之外，其余智能指针都符合RAII和像指针一样访问的行为

他们主要的区别在于：拷贝时的思路不一样

3.1 auto_ptr

auto_ptr是C++98时设计出来的智能指针

它的特点是：

• 拷贝时把被拷贝对象的资源的管理权转移给拷贝对象，导致被拷贝对象被悬空，以及访问被拷贝对象报错的问题

所以在C++11设计出新的智能指针之后，强烈建议不要使用auto_ptr，其实在C++11设计新的智能指针之前很多公司也是命令禁止使用这个智能指针的！！！

3.2 unique_ptr

unique_ptr是C++11设计出来的智能指针，它的名字翻译出来是：唯一指针。

它的特点是：不支持拷贝，只支持移动。所以如果不需要拷贝的场景就非常建议使用他！！！

• 除此之外，智能指针还可以被转换成 bool 类型，因为unique_ptr中有operator bool

int main()
{
	unique_ptr<A> up1(new A);
	//unique_ptr<A> up2(up1);//不允许拷贝
	unique_ptr<A> up2(move(up1));//只允许移动
	if (up2)
	{
		cout << "operator bool" << endl;
	}
	return 0;
}

3.3 shared_ptr

shared_ptr是C++11设计出来的智能指针，他被翻译成：共享指针

它的特点是：支持拷贝，也支持移动。如果需要拷贝的场景就需要使用它，底层是用引用计数的方式实现的

• shared_ptr和unique_ptr都支持了operator bool的类型转换，如果智能指针对象是一个空对象没有管理资源，则返回false，否则返回true，意味着我们可以直接把智能指针对象给if判断是否为空。
• shared_ptr和unique_ptr都得构造函数都使用explicit 修饰，防止普通指针隐式类型转换成智能指针对象。

注意：shared_ptr会引起循环引用的问题（后面再看）！！！

ok，接下来就来看看智能指针的原理------

四、智能指针的原理以及模拟实现shared_ptr

4.1 auto_ptr和unique_ptr模拟实现

auto_ptr、unique_ptr这两个智能指针的实现比较简单，大家了解一下原理即可。

• auto_ptr的思路是拷贝时转移资源的管理权给被拷贝对象，这种思路是不被认可的，也不建议使用
• unique_ptr的思路是不支持拷贝

ok，我们先来看一下auto_ptr的实现------

auto_ptr的思路是拷贝时转移资源的管理权给被拷贝对象，然后使拷贝对象悬空，在这种情况下，我们是不知道会使拷贝对象悬空，如果后面接着使用拷贝对象，就会导致对空指针的使用

template<class T>
class auto_ptr
{
public:
	explicit auto_ptr(T* ptr)
		:_ptr(ptr)
	{}
	~auto_ptr()
	{
		cout << "delete:" << _ptr << endl;
		delete[] _ptr;
	}
	auto_ptr(const auto_ptr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = nullptr;
	}
	auto_ptr& operator=(const auto_ptr<T>& ap)
	{
		//拷贝时转移被拷贝对象的资源的管理权给拷贝对象
		if (this != &ap)
		{
			//先释放自己的资源
			if (_ptr)
			{
				delete _ptr;
			}
			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}
		return this;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	T& operator[](size_t i)
	{
		return _ptr[i];
	}
private:
	T* _ptr;//因为我们申请的资源都是放在一个指针里面的
};

我们调试一下看拷贝时是否进行了资源管理权的转移------

• unique_ptr模拟实现

unique_ptr的思路是不支持拷贝，只支持移动

unique_ptr只支持移动，然后unique_ptr也会转移转移资源的管理权给被拷贝对象，然后使拷贝对象悬空，在这种情况下，我们是知道的

template<class T>
class unique_ptr
{
public:
	explicit unique_ptr(T* ptr)
		:_ptr(ptr)
	{}
	~unique_ptr()
	{
		cout << "delete:" << _ptr << endl;
		delete[] _ptr;
	}
	//unique_ptr支持移动
	unique_ptr(unique_ptr<T>&& up) noexcept
		:_ptr(up._ptr)
	{
		up._ptr = nullptr;
	}
	unique_ptr<T>& operator=(unique_ptr<T>&& up)
	{
		delete _ptr;
		_ptr = up._ptr;
		up._ptr = nullptr;
		return this;
	}
	//unique_ptr不支持拷贝，那就不能让程序调用拷贝
	unique_ptr(const unique_ptr<T>& up) = delete;
	unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	T& operator[](size_t i)
	{
		return _ptr[i];
	}
private:
	T* _ptr;//因为我们申请的资源都是放在一个指针里面的
};

ok，上面这两个智能指针的模拟实现了解即可，接下来，我们要重点掌握shared_ptr的模拟实现，以及引用计数的设计------

4.2 shared_ptr模拟实现（面试手撕）

ok，当我们对上面我们自己写的智能指针的代码进行改写，发现当我们执行上面的代码时，我们会析构两次，这就会导致一些问题。

那接下来，我们就要解决拷贝的问题------

通过前面的学习，我们知道shared_ptr的底层是靠引用计数的方式完成的，那我们就该来想一想，这里我们该怎么实现这个引用计数呢？

• 我们是这样写吗？直接在成员变量中加入引用计数吗？

ok，如果是这样写的话，当我们析构时会有问题------

😯，既然我们必须是同一个计数，我们就可以在成员变量中定义一个静态成员变量，这样我们就是同一个计数了------

可是这个真的对吗？ok，当我们只有一个资源的时候，这个是对的，但是我们不可能只有一个资源，那当我们的申请的资源数量不止一个的时候，这还对吗？

我们知道，静态成员变量是属于这个类的所有对象

我们这里希望的是：一个资源对应一个引用计数，如果我们在成员变量这里定义一个静态成员变量，这个静态成员变量属于这个类中的所有对象，也就意味着所有的资源共用一个引用计数，这很明显是不符合我们的要求。

那我们怎么做呢？

我们可不可以不在智能指针中存计数，我们可以存一个计数指针，然后每当我们进行构造智能指针对象的时候，我们就new一个计数指针出来（初始值为1），然后存在我们这个成员变量中的计数指针中，每当我们要进行拷贝的时候，我们就++（*计数指针），这样是不是就可以让一个资源对应一个计数了。

ok，我们通过上面的思路实现我们的拷贝构造------

//拷贝构造
shared_ptr(const shared_ptr<T>& sp)
	//引用对象，const对象以及没有默认构造的对象都在初始化列表初始化
	:_ptr(sp._ptr)
	,_count(sp._count)
{
	//++计数，意味着多了一个指向这个资源的对象
	++(*_count);
}

拷贝构造写完了，接下来，我们来看看这个析构函数该怎么写------

这里的析构函数不能像上面写的那种写法，因为这里会有多个对象指向这个资源，所以当引用计数==0时，也就意味着到了最后一个智能指针指向该资源，我们就应该释放相应的资源

总结一下：

shared_ptr 的引用计数机制实现了安全的多对象资源共享：

1. 多个智能指针可指向同一动态分配的资源

2. 每增加一个共享者，引用计数递增

3. 每减少一个共享者（指针析构或重置），引用计数递减

4. 当引用计数降为 0 时，表示资源已无使用者，自动释放内存

~shared_ptr()
{
	//上来就--计数，当计数==0时，说明到了最后一个智能指针指向该资源，需要释放该资源
    //若计数！=0，说明此时还有多个智能指针对象指向该资源，不能释放资源
    //如果此时释放，会导致空指针
	if (--(*_count) == 0)
	{
		delete _ptr;
		delete _count;
	}
}

ok，这样我们就实现拷贝构造和析构函数！

但是，这里最难的是赋值重载，这个赋值重载该怎么写呢？

• 是这样写吗？

我一上来就直接释放sp1，这对吗？

ok，这明显是不对的，如果当前资源只有一个对象指向该资源，这是对的，但是，我们只会有一个资源吗？很显然是不可能的，我们不能直接把sp1指向的资源一上来就释放，因为sp1指向的资源有可能有多个对象管理，如果我们直接将sp1释放，其余指向该资源的对象就是指向空，后面再对这些对象进行访问的时候，就会出现对空指针进行访问。

所以我们不能直接释放sp1所指向的资源，而是应该像析构函数中的做法------

我们先 --计数

也许会有uu会感到疑惑，为什么这里要--计数？

因为如果这里不止一个对象指向这个资源，我们就不能进行释放资源的操作

--计数的目的就是为了让sp1（上图中举的例子）和其他指向这块资源的对象分离开，就表示我这个sp1不指向这块资源了，这样我就让sp1和sp3指向相同的资源，共同管理sp3指向的资源

• 如果这个只有sp1指向这块资源------

--计数，然后这时就可以释放sp1所指向的资源，然后转向和sp3共同管理sp3指向的资源

ok，我们总结一下------

• 引用计数减到0：当前对象是最后一个管理者，需要释放资源

• 引用计数未减到0：还有其他对象在管理，我们只是"离开"这个资源的管理团队

通过上面的操作，接下来我们就执行sp1于sp3共同管理sp3所指向的资源的操作：

//赋值重载
//sp1=sp3
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
	//不能自己和自己赋值
	if (this != &sp)
	{
		if (--(*_count) == 0)
		{
			delete _ptr;
			delete _count;
		}
		//让sp1和sp3共同管理资源
		_ptr = sp._ptr;
		_count = sp._count;
		//++计数，表示管理这块资源的对象多了一个
		++(*_count);
	}
	return *this;
}

但是这里还有小问题：

int main()
{
	carrot::shared_ptr<A> sp1(new A);
	carrot::shared_ptr<A> sp2(sp1);
	carrot::shared_ptr<A> sp3(new A);
	//sp1 = sp3;
	sp1 = sp1;//这里可以判断
	sp1 = sp2;//这里就无法判断
	return 0;
}

这里没啥太大问题，只是当执行sp1=sp2时，这里的操作就白做了，我们可改进一下：

//赋值重载
//sp1=sp3
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
	//不能自己和自己赋值
	//if (this != &sp)
	if(_ptr!=sp._ptr)//判断资源是否相等，可以避免相同资源之间的赋值
	{
		if (--(*_count) == 0)
		{
			delete _ptr;
			delete _count;
		}
		//让sp1和sp3共同管理资源
		_ptr = sp._ptr;
		_count = sp._count;
		//++计数，表示管理这块资源的对象多了一个
		++(*_count);
	}
	return *this;
}

ok，这样shared_ptr的模拟实现就基本上完成了，shared_ptr的模拟实现是很重要的，面试的时候是有可能直接让你手撕的，还有这几个智能指针的区别也是面试中经常被问的！！！

五、删除器

智能指针析构时默认是进行delete释放资源，这也就意味着如果不是new出来的资源，交给智能指针进行管理的，析构时就会崩溃。

也就是底层是写死的，只能对new出来的资源进行delete释放资源！！！（new int[10 ]都不行，只能是new int）

• 解决方案：

智能指针支持在构造时给一个删除器

所谓删除器的本质就是一个可调用对象，这个可调用对象中实现你想要的释放资源的方式，当构造智能指针时，给了定制的删除器，在这个智能指针析构时就会去调用删除器去释放资源。

我们来看一下库中的是不是也是这样------

没事哒~没事哒，有解决方法------

• 我们先来看shared_ptr:

shared_ptr允许我们在构造的时候传这个删除器！！！

//函数指针
template<class T>
void DeleteArrayFunc(T* ptr)
{
	delete[] ptr;
}
//仿函数
template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};
int main()
{
	//仿函数
	std::shared_ptr<A> sp2(new A[10], DeleteArray<A>());
	//函数指针
	std::shared_ptr<A> sp3(new A[10], DeleteArrayFunc<A>);
	//lambda表达式
	std::shared_ptr<A> sp4(new A[10], [](A* ptr) {delete[] ptr; });
    
   //不是new出来的
    std::shared_ptr<FILE> sp5(fopen("test.c", "r"), [](FILE* ptr) { fclose(ptr); });
    
	return 0;
}

• 看完shared_ptr，我们来看unique_ptr中的

unique_ptr中的删除器的位置和shared_ptr中的删除器的位置不太一样

说实话，这两个删除器的位置的写法感觉像是两个人的思路😂

unique_ptr中的删除器的用法要比shared_ptr中的删除器的用法要复杂那么亿丢丢！

//函数指针
template<class T>
void DeleteArrayFunc(T* ptr)
{
	delete[] ptr;
}
//仿函数
template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};
int main()
{
	//仿函数
	std::unique_ptr<A, DeleteArray<A>> up1(new A[10]);
	//函数指针
	std::unique_ptr<A, void(*)(A*)> up2(new A[10], DeleteArrayFunc<A>);
	//lambda
    auto del = [](A* ptr) {delete[] ptr; };
    std::unique_ptr<A, decltype(del)> up3(new A[10], del);  //lambda
	return 0;
}

ok，这里函数指针不能像仿函数那样写------（原因）

ok，我们也要模拟实现定制删除器------

那我们是按照shared_ptr的写法还是按照unique_ptr的写法呢？

• 我们先来尝试一下shared_ptr的写法------

我们在构造的时候传入删除器对象，然后肯定需要一个成员变量去接收这个删除器对象。

但是这里有个问题，就是我在这里写的这模板参数是这个构造函数的模板参数，只能在构造函数中使用，不能在其他地方使用。

那咋搞呢？换成unique_ptr的那种写法吗？如果换成unique_ptr的那种写法就会显得很麻烦

我们可以这样写------

• 然后我们就可以调用_del去释放相应的资源：

但是加上之后，还是有问题，如果我申请的资源是new出来的呢，就不需要传这个删除器对象了。

所以我们还要加上原先不需要传删除器对象的构造------

但是加上之后，还是有问题------

• 所以我们要给functio加上一个默认值------给个lambda表达式：

private:
	T* _ptr;
	//static int _count;//引用计数
	int* _count;
	//底层默认允许delete
	function<void(T*)> _del= [](T* ptr) {delete ptr; };
};

shared_ptr模拟实现完整代码（含删除器以及相应改进）

#include<iostream>
#include<functional>
using namespace std;
//函数指针
template<class T>
void DeleteArrayFunc(T* ptr)
{
	delete[] ptr;
}
//仿函数
template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};
namespace carrot
{
	template<class T>
	class shared_ptr
	{
	public:
		//构造
		template<class D>
		explicit shared_ptr(T* ptr,D del)
			:_ptr(ptr)
			,_count(new int(1))
			,_del(del)
		{}

		explicit shared_ptr(T* ptr)
			:_ptr(ptr)
			, _count(new int(1))
		{}
		//拷贝构造
		shared_ptr(const shared_ptr<T>& sp)
			//引用对象，const对象以及没有默认构造的对象都在初始化列表初始化
			:_ptr(sp._ptr)
			,_count(sp._count)
		{
			//++计数，意味着多了一个指向这个资源的对象
			++(*_count);
		}
		void release()
		{
			if (--(*_count) == 0)
			{
				//delete _ptr;
				_del(_ptr);
				delete _count;
			}
		}
		~shared_ptr()
		{
			////上来就--计数，当计数==0时，说明到了最后一个智能指针指向该资源，需要释放该资源
			//if (--(*_count) == 0)
			//{
			//	//delete _ptr;
			//	_del(_ptr);
			//	delete _count;
			//}

			//上面写法替换成下面
			release();
		}
		//赋值重载
		//sp1=sp3
		shared_ptr<T>& operator=(shared_ptr<T>& sp)
		{
			//不能自己和自己赋值
			//if (this != &sp)
			if(_ptr!=sp._ptr)//判断资源是否相等，可以避免相同资源之间的赋值
			{
				//if (--(*_count) == 0)
				//{
				//	//delete _ptr;
				//	_del(_ptr);
				//	delete _count;
				//}
				
				//上面写法替换成下面
				release();

				//让sp1和sp3共同管理资源
				_ptr = sp._ptr;
				_count = sp._count;
				//++计数，表示管理这块资源的对象多了一个
				++(*_count);
			}
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		T& operator[](size_t i)
		{
			return _ptr[i];
		}
	private:
		T* _ptr;
		//static int _count;//引用计数
		int* _count;
		//底层默认允许delete
		function<void(T*)> _del= [](T* ptr) {delete ptr; };
	};
}
int main()
{
	//carrot::shared_ptr<A> sp1(new A);
	//carrot::shared_ptr<A> sp2(sp1);
	//carrot::shared_ptr<A> sp3(new A);
	////sp1 = sp3;
	//sp1 = sp1;//这里可以判断
	//sp1 = sp2;//这里就无法判断
	//carrot::shared_ptr<A> sp1(new A);
	//仿函数
	carrot::shared_ptr<A> sp2(new A[10], DeleteArray<A>());
	//函数指针
	//carrot::shared_ptr<A> sp3(new A[10], DeleteArrayFunc<A>);
	//lambda表达式
	//carrot::shared_ptr<A> sp4(new A[10], [](A* ptr) {delete[] ptr; });
	//不是new出来的
	//std::shared_ptr<FILE> sp5(fopen("test.c", "r"), [](FILE* ptr) { fclose(ptr); });
	////仿函数
	//std::unique_ptr<A, DeleteArray<A>> up1(new A[10]);
	////函数指针
	//std::unique_ptr<A, void(*)(A*)> up2(new A[10], DeleteArrayFunc<A>);
	////lambda
	//auto del = [](A* ptr) {delete[] ptr; };
	//std::unique_ptr<A, decltype(del)> up3(new A[10], del);  //lambda
	return 0;
}

shared_ptr和unique_ptr都特化了new[ ]

由于 new[ ] 经常使用该，所以为了简洁一点， shared_ptr和unique_ptr都特化了一份 [ ] 的版本，

unique_ptr<Date[]> up1(new Date[5]);
shared_ptr_ptr<Date[]> sp1(new Date[5]);

这样就可以管理new [ ] 的资源了！！！

class A
{
public:
	A()
	{}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};
int main()
{
	std::unique_ptr<A[]> up1(new A[5]);

	std::shared_ptr<A[]> sp1(new A[5]);
	return 0;
}

六、make_shared

• shared_ptr 除了支持用指向资源的指针构造，还支持 make_shared 用初始化资源对象的值直接构造。

make_shared - C++ Reference

底层是一个函数模板，底层构造一个shared_ptr对象呢返回，拿着这些参数去构造一个shared_ptr，然后返回

class A
{
public:
	A(int a1,int a2)
		:_a1(a1)
		,_a2(a2)
	{}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};
int main()
{
	//shared_ptr<A> sp6 = make_shared<A>(1, 2);
	auto sp6 = make_shared<A>(1, 2);
    auto sp7 = make_shared<int>(3);

	return 0;
}

七、shared_ptr和weak_ptr

7.1 shared_ptr循环引用问题

shared_ptr大多数情况下管理资源非常合适，支持RAII，也支持拷贝。

但是在循环引用的场景下会导致资源没有得到释放，从而导致内存泄漏，所以我们要认识循环引用的场景和资源没有释放的原因，并且学会使用weak_ptr解决这种问题。

struct ListNode
{
	int _data;
	std::shared_ptr<ListNode> _next;
	std::shared_ptr<ListNode> _prev;
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int main()
{
	// 循环引⽤ -- 内存泄露
	std::shared_ptr<ListNode> n1(new ListNode);
	std::shared_ptr<ListNode> n2(new ListNode);
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	n1->_next = n2;
	n2->_prev = n1;
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	return 0;
}

我们来看一下这段代码，我们构造了一个节点的结构体，new了两个节点出来，让他们的_next指针和_prev指针分别指向对方------

ok，当程序结束，n1和n2进行析构的时候，出现了问题：

通过上图，我们发现，虽然n1和n2已经正常析构，并且也没有指向相应的节点资源，但是左边节点的_next指针还指向右边节点，右边节点的_prev指针还指向左边节点

n1和n2析构后，管理两个节点的引用计数减到1

1. 右边的节点什么时候释放呢，左边节点中的_next指针管着呢，_next析构后，右边的节点就释放了。
2. _next指针什么时候析构呢，_next指针时左边节点的成员，左边节点释放了，_next指针就析构了
3. 左边节点什么时候释放呢，左边节点由右边节点中的_prev指针管着呢，_prev指针析构后，左边节点就释放了
4. _prev指针什么时候析构呢，_prev是右边节点的成员，右边节点释放了，_prev就析构了

至此逻辑上成功形成回旋镖似的循环引用，谁都不会释放就形成了循环引用，导致内存泄露

那我们该怎么解决这个问题呢？那就要使用到weak_ptr

7.2 weak_ptr

weak_ptr不支持RAII，也不支持访问资源，所以我们看到weak_ptr构造时不支持绑定到资源，只支持绑定到shared_ptr，绑定到shared_ptr时，不增加shared_ptr的引用计数，那么就可以解决上述的循环引用的问题

struct ListNode
{
	int _data;

	/*std::shared_ptr<ListNode> _next;
	std::shared_ptr<ListNode> _prev;*/

	// 这⾥改成weak_ptr，当n1->_next = n2;绑定shared_ptr时
	// 不增加n2的引⽤计数，不参与资源释放的管理，就不会形成循环引⽤了

	std::weak_ptr<ListNode> _next;
	std::weak_ptr<ListNode> _prev;

	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int main()
{
	// 循环引⽤ -- 内存泄露
	std::shared_ptr<ListNode> n1(new ListNode);
	std::shared_ptr<ListNode> n2(new ListNode);
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	n1->_next = n2;
	n2->_prev = n1;
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	return 0;
}

weak_ptr绑定到shared_ptr时不会增加它的引用计数，_next和 _prev不参与资源释放管理逻辑，就成功打破了循环引用，就成功解决了这里的问题

从上图中我们可以清晰看到，weak_ptr没有重载operator*和operator->等，因为他不参与资源管理，那么如果他绑定的shared_ptr已经释放了资源，那么他去访问资源就是很危险的。

weak_ptr支持expired检查指向的资源是否过期，use_count也可以获取shared_ptr的引用计数，weak_ptr想访问资源时，可以调用lock返回一个管理资源的shared_ptr，如果资源已经被释放，返回的shared_ptr是一个空对象；如果资源没有释放，则返回的shared_ptr访问资源是安全的

int main()
{
	std::shared_ptr<string> sp1(new string("111111"));
	std::shared_ptr<string> sp2(sp1);
	std::weak_ptr<string> wp = sp1;
	cout << wp.expired() << endl;
	cout << wp.use_count() << endl;
	// sp1和sp2都指向了其他资源，则weak_ptr就过期了
	sp1 = make_shared<string>("222222");
	cout << wp.expired() << endl;
	cout << wp.use_count() << endl;
	sp2 = make_shared<string>("333333");
	cout << wp.expired() << endl;
	cout << wp.use_count() << endl;
	wp = sp1;
	//std::shared_ptr<string> sp3 = wp.lock();
	auto sp3 = wp.lock();
	cout << wp.expired() << endl;
	cout << wp.use_count() << endl;
	*sp3 += "###";
	cout << *sp1 << endl;
	return 0;
}

• weak_ptr的底层结构------

template<class T>
class weak_ptr
{
public:
	weak_ptr()
	{}
	weak_ptr(const shared_ptr<T>& sp)
		:_ptr(sp._ptr)
	{}
	//不参与资源的管理
private:
	T* _ptr = nullptr;
    //int* _count;
};

八、shared_ptr的线程安全问题

8.1 说明

【shared_ptr的线程安全问题】这个模块可以在Linux学完【多线程】之后再来看，就很明白了。

8.2 理论

• shared_ptr的引用计数对象在堆上，如果多个shared_ptr对象在多个线程中，进行shared_ptr的拷贝析构时会访问修改引用计数，就会存在线程安全问题，所以shared_ptr引用计数是需要加锁或者原子操作保证线程安全的
• shared_ptr指向的对象也是有线程安全的问题的，但是这个对象的线程安全问题不归shared_ptr管，它也管不了，应该有 外层使用shared_ptr的人进行线程安全的控制

下面的程序会崩溃或者A资源没释放，carrot::shared_ptr引用计数从int* 改成atomic<int>*就可以保证引用计数的线程安全问题，或者使用互斥锁加锁也可以

#include<functional>
#include<thread>
#include<mutex>
//函数指针
template<class T>
void DeleteArrayFunc(T* ptr)
{
	delete[] ptr;
}
//仿函数
template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};
namespace carrot
{
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
		{}
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
		{}
		//不参与资源的管理
	private:
		T* _ptr = nullptr;
	};
	template<class T>
	class shared_ptr
	{
	public:
		//构造
		template<class D>
		explicit shared_ptr(T* ptr,D del)
			:_ptr(ptr)
			,_count(new int(1))
			,_del(del)
		{}

		explicit shared_ptr(T* ptr)
			:_ptr(ptr)
			, _count(new int(1))
		{}
		//拷贝构造
		shared_ptr(const shared_ptr<T>& sp)
			//引用对象，const对象以及没有默认构造的对象都在初始化列表初始化
			:_ptr(sp._ptr)
			,_count(sp._count)
		{
			//++计数，意味着多了一个指向这个资源的对象
			++(*_count);
		}
		void release()
		{
			if (--(*_count) == 0)
			{
				//delete _ptr;
				_del(_ptr);
				delete _count;
			}
		}
		~shared_ptr()
		{
			////上来就--计数，当计数==0时，说明到了最后一个智能指针指向该资源，需要释放该资源
			//if (--(*_count) == 0)
			//{
			//	//delete _ptr;
			//	_del(_ptr);
			//	delete _count;
			//}

			//上面写法替换成下面
			release();
		}
		//赋值重载
		//sp1=sp3
		shared_ptr<T>& operator=(shared_ptr<T>& sp)
		{
			//不能自己和自己赋值
			//if (this != &sp)
			if(_ptr!=sp._ptr)//判断资源是否相等，可以避免相同资源之间的赋值
			{
				//if (--(*_count) == 0)
				//{
				//	//delete _ptr;
				//	_del(_ptr);
				//	delete _count;
				//}
				
				//上面写法替换成下面
				release();

				//让sp1和sp3共同管理资源
				_ptr = sp._ptr;
				_count = sp._count;
				//++计数，表示管理这块资源的对象多了一个
				++(*_count);
			}
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		T& operator[](size_t i)
		{
			return _ptr[i];
		}
		int use_count()
		{
			return *_count;
		}
	private:
		T* _ptr;
		//static int _count;//引用计数
		int* _count;
		//底层默认允许delete
		function<void(T*)> _del= [](T* ptr) {delete ptr; };
	};
}
struct AA
{
	int _a1 = 0;
	int _a2 = 0;
	~AA()
	{
		cout << "~AA()" << endl;
	}
};

int main()
{
	carrot::shared_ptr<AA> p(new AA);
	const size_t n = 100000;
	mutex mtx;
	auto func = [&]()
		{
			for (size_t i = 0; i < n; ++i)
			{
				// 这里智能指针拷贝会++计数 
				carrot::shared_ptr<AA> copy(p);
				{
					unique_lock<mutex> lk(mtx);
					copy->_a1++;
					copy->_a2++;
				}
			}
		};

	thread t1(func);
	thread t2(func);
	t1.join();
	t2.join();
	cout << p->_a1 << endl;
	cout << p->_a2 << endl;
	cout << p.use_count() << endl;

	return 0;
}

carrot::shared_ptr引用计数从int* 改成atomic<int>*就可以保证引用计数的线程安全问题

改完这个之后也要改动相应的构造------

8.3 保证线程安全的shared_ptr完整代码

#include<functional>
#include<atomic>
//函数指针
template<class T>
void DeleteArrayFunc(T* ptr)
{
	delete[] ptr;
}
//仿函数
template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};
namespace carrot
{
	template<class T>
	class shared_ptr
	{
	public:
		//构造
		template<class D>
		explicit shared_ptr(T* ptr,D del)
			:_ptr(ptr)
			,_count(new atomic<int>(1))
			,_del(del)
		{}

		explicit shared_ptr(T* ptr)
			:_ptr(ptr)
			, _count(new atomic<int>(1))
		{}
		//拷贝构造
		shared_ptr(const shared_ptr<T>& sp)
			//引用对象，const对象以及没有默认构造的对象都在初始化列表初始化
			:_ptr(sp._ptr)
			,_count(sp._count)
		{
			//++计数，意味着多了一个指向这个资源的对象
			++(*_count);
		}
		void release()
		{
			if (--(*_count) == 0)
			{
				//delete _ptr;
				_del(_ptr);
				delete _count;
			}
		}
		~shared_ptr()
		{
			////上来就--计数，当计数==0时，说明到了最后一个智能指针指向该资源，需要释放该资源
			//if (--(*_count) == 0)
			//{
			//	//delete _ptr;
			//	_del(_ptr);
			//	delete _count;
			//}

			//上面写法替换成下面
			release();
		}
		//赋值重载
		//sp1=sp3
		shared_ptr<T>& operator=(shared_ptr<T>& sp)
		{
			//不能自己和自己赋值
			//if (this != &sp)
			if(_ptr!=sp._ptr)//判断资源是否相等，可以避免相同资源之间的赋值
			{
				//if (--(*_count) == 0)
				//{
				//	//delete _ptr;
				//	_del(_ptr);
				//	delete _count;
				//}
				
				//上面写法替换成下面
				release();

				//让sp1和sp3共同管理资源
				_ptr = sp._ptr;
				_count = sp._count;
				//++计数，表示管理这块资源的对象多了一个
				++(*_count);
			}
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		T& operator[](size_t i)
		{
			return _ptr[i];
		}
		//返回引用计数
		int use_count()
		{
			return *_count;
		}
	private:
		T* _ptr;
		//static int _count;//引用计数
		//int* _count;//这里不能保证线程安全
		atomic<int>* _count;//这样可以保证线程安全
		//底层默认允许delete
		function<void(T*)> _del= [](T* ptr) {delete ptr; };
	};
}

九、 历史发展：C++11和boost中智能指针的关系

• Boost库是为C++语言标准库提供扩展的一些C++程序库的总称，Boost社区建立的初衷之一就是为C++的标准化工作提供可供参考的实现，Boost社区的发起人Dawes本人就是C++标准委员会的成员之一。在Boost库的开发中，Boost社区也在这个方向上取得了丰硕的成果，C++11及之后的新语法和库有很多都是从Boost中来的（直接借鉴）。
• C++98中产生了第一个智能指针auto_ptr（飞舞智能指针）。
• C++ Boost给出了更实用的scoped_ptr / scoped_array和shared_ptr/shared_array和weak_ptr等。
• C++TR1，引入了shared_ptr等，不过注意的是TR1并不是标准版。
• C++11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr（除了unique_ptr，其它都没有换名字），以及Boost的 [ ] 没有采取特化。并且，这些智能指针的实现原理是参考boost中的实现的。

十、内存泄漏问题

10.1 什么是内存泄漏，内存泄漏的危害

10.1.1 理论：什么是内存泄漏？

• 什么是内存泄漏？

**内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存，一般是忘记释放或者发生异常释放程序未能执行导致的。**内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

• 内存泄漏的危害

**普通程序运行一会就结束了出现内存泄漏问题也不大，进程正常结束，页表的映射关系解除，物理内存也可以释放。**长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务、长时间运行的客户端等等，不断出现内存泄漏会导致可用内存不断变少，各种功能响应越来越慢，最终卡死。

对于大型的APP来说，这个就属于是事故了。

int main()
{
	// 申请⼀个1G未释放，这个程序多次运⾏也没啥危害
	// 因为程序⻢上就结束，进程结束各种资源也就回收了
	char* ptr = new char[1024 * 1024 * 1024];
	cout << (void*)ptr << endl;
	return 0;
}

10.2 如何检测内存泄漏（了解一下）

这里给大家推荐两篇博客，uu们简单了解一下 不同操作系统下然后检测内存泄漏------

linux下内存泄漏检测：Linux下几款C++程序中的内存泄露检查工具_c++内存泄露工具分析-CSDN博客

windows下使用第三方工具：windows下的内存泄露检测工具VLD使用_windows内存泄漏检测工具-CSDN博客

10.3 如何避免内存泄漏

• 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。

注意：这个是理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。

• 尽量使用智能指针来管理资源，如果自己场景比较特殊，采用RAII思想自己造个轮子管理。定期使用内存泄漏工具检测，尤其是每次项目快上线前，不过有些工具不够靠谱，或者是收费。

总结一下： 内存泄漏非常常见，解决方案分为两种------

结尾

uu们，本文的内容到这里就全部结束了，再次感谢您的阅读！

结语：希望对学习C++相关内容的uu有所帮助，不要忘记给博主"一键三连"哦！