【C++】智能指针原理以及详细讲解shared_ptr精简版实现

📚 博主的专栏

🐧 Linux   |   🖥️ C++   |   📊 数据结构  | 💡C++ 算法 | 🌐 C 语言

上篇文章:   C++异常

下篇文章：C++特殊类设计

目录

内存泄漏

内存泄漏分类（了解）

堆内存泄漏(Heap leak)

系统资源泄漏

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

如何避免内存泄漏

智能指针的使用及原理

RAII

智能指针的原理

总结一下智能指针的原理：

早期的std::auto_ptr自动指针（不建议使用、管理权转移，被拷贝对象悬空，有风险）

C++委员会部分人就做了boost库

unique_ptr（特点：不支持拷贝、没有风险，建议使用）

shared_ptr（引入引用计数use_count，全能型）

shared_ptr的原理：

实现一个shared_ptr(重点)

引用计数如何设计

析构：

***最复杂的是赋值***：

实现operator* ，operator->()

线程安全问题：

std::shared_ptr的循环引用

weak_ptr

定制删除器

  最后的精简版shared_ptr封装：

---

先看看上篇文章所讲的使用异常捕获，来处理防止内存泄漏的问题的代码：

示例代码： 

void Func()
{int* p1 = new int[10];int* p2 = nullptr;try{p2 = new int[20]; 如果p2没new成功，就会被捕获去释放p1try{int len, time;cin >> len >> time;cout << Division(len, time) << endl; // throw}catch (...){delete[] p1;cout << "delete:" << p1 << endl;delete[] p2;cout << "delete:" << p2 << endl;throw;  // 捕获什么抛出什么}}catch (...){delete[] p1;cout << "delete:" << p1 << endl;throw;}delete[] p1;cout << "delete:" << p1 << endl;delete[] p2;cout << "delete:" << p2 << endl;
}

这里是一个非常麻烦的过程，只要我们每new一个指针，就需要去处理他的异常。不然就会导致内存泄漏。

内存泄漏

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

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

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

内存泄漏分类（了解）

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

堆内存泄漏(Heap leak)

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

系统资源泄漏

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

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

在linux下内存泄漏检测：linux下几款内存泄漏检测工具

在windows下使用第三方工具：VLD工具说明

其他工具：内存泄漏工具比较

如何避免内存泄漏

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

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

能指针来管理才有保证。

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

智能指针的使用及原理

类似于前面文章所讲过的LockGuard的模拟实现:借助构造函数和析构函数来帮助完成自动化的释放指针空间

class LockGuard
{
public:LockGuard(mutex& mtx):_mtx(mtx){_mtx.lock();}~LockGuard(){_mtx.unlock();}
private:mutex& _mtx;
};

示例：

和LockGuard的思路一样，使用构造函数保存资源，析构函数释放资源。

无论是正常结束，还是抛异常结束，只要对象出了作用域，就会被自动析构

double Division(int a, int b)
{if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void Func()
{int* p1 = new int[10];int* p2 = nullptr;try{p2 = new int[20]; 如果p2没new成功，就会被捕获去释放p1try{int len, time;cin >> len >> time;cout << Division(len, time) << endl; // throw}catch (...){delete[] p1;cout << "delete:" << p1 << endl;delete[] p2;cout << "delete:" << p2 << endl;throw;  // 捕获什么抛出什么}}catch (...){delete[] p1;cout << "delete:" << p1 << endl;throw;}delete[] p1;cout << "delete:" << p1 << endl;delete[] p2;cout << "delete:" << p2 << endl;
}//和LockGuard的思路一样，无论是正常结束，还是抛异常结束，只要对象出了作用域，就会被自动析构
class SmartPtr
{
public:SmartPtr(int* ptr):_ptr(ptr)//将外面new好的指针保存起来{}~SmartPtr()//析构函数的时候释放{cout << "delete : " << _ptr << endl;delete[] _ptr;}
private:int* _ptr;
};int main()
{SmartPtr sp1(new int[10]);return 0;
}

我们这里是捕获了一个非法参数的异常：

有了智能指针，如何解决上面的问题：

对于Func函数就可以直接这样写：

void Func()
{SmartPtr sp1(new int[10]);SmartPtr sp2(new int[20]);int len, time;cin >> len >> time;cout << Division(len, time) << endl;
}

运行结果：

RAII

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

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

• 不需要显式地释放资源
• 采用这种方式，对象所需的资源在其生命期内始终保持有效

智能指针的原理

实际情况中可传多种参数，也有可能会用到原生指针、也有可能需要用到operator* 、->、[]、...：

template<class T>
class SmartPtr
{
public:SmartPtr(T* ptr):_ptr(ptr)//将外面new好的指针保存起来{}~SmartPtr()//析构函数的时候释放{cout << "delete : " << _ptr << endl;delete[] _ptr;}T* get(){return _ptr;}//重载operator* 、->、[]、...T& operator*(){return *_ptr;}T* operator->(){return _ptr;}T& operator[](size_t i){return _ptr[i];}
private:T* _ptr;
};

示例：

struct Date
{int _year;int _month;int _day;
};
int main()
{SmartPtr<int> sp1(new int);*sp1 = 10;cout << *sp1 << endl;SmartPtr<Date> sparray = new Date();// 需要注意的是这里应该是sparray.operator->()->_year = 2018;// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->sparray->_year = 2018;sparray->_month = 1;sparray->_day = 1;
}

总结一下智能指针的原理：

1. RAII特性

2. 重载operator*和opertaor->，具有像指针一样的行为。

智能指针解决的最大的问题在于：拷贝的问题

在这里使用sp2拷贝构造sp1，导致析构两次（因为浅拷贝）。不能深拷贝，我模拟的就是指针的行为，我就是想让两个指针变量共同管理这块资源

早期拷贝问题的解决方法： C++98提供的std::auto_ptr

早期的std::auto_ptr自动指针（不建议使用、管理权转移，被拷贝对象悬空，有风险）

std::auto_ptr文档

#include<memory>

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

auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理

示例：

int main()
{auto_ptr<int> sp1(new int[10]);auto_ptr<int> sp2(sp1);return 0;
}

解决办法：拷贝构造的时候转移管理权（资源），不是移动构造（这里传的是左值），但是类似，区别就是，移动构造转移的是将亡对象的值。

这里会导致 sp1 对象悬空，而sp1是一个左值，在之后可能还会被访问到，就会出现程序崩溃。

C++委员会部分人就做了boost库

实际上boost库对于C++库标准的发展做出了重大的贡献。

Boost库是为C++语言标准库提供扩展的一些C++程序库的总称，由Boost社区组织开发、维护。Boost库可以与C++标准库完美共同工作，并且为其提供扩展功能。

1. C++ 98 中产生了第一个智能指针auto_ptr.

2. C++ boost给出了更实用的scoped_ptr、scoped_ptr和shared_ptr、以及weak_ptr.

3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。

4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

unique_ptr（特点：不支持拷贝、没有风险，建议使用）

某种意义下可以理解为唯一指针

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理
他是支持很多种构造的：不支持拷贝构造 

示例： 

class A
{
public:~A(){cout << "~A()" << endl;}
private:int _a1 = 1;int _a2 = 1;
};//拷贝问题
int main()
{unique_ptr<A> sp1(new A);return 0;
}

运行结果：

不支持拷贝、也不支持赋值：

使用get（）可获取到原生指针：

也可以直接使用sp1做条件判断：调用了operator bool ，判断指针是否为空

***可以使用operator->***，访问到成员变量（类似于迭代器那里）

如果存在多个对象，还能这样使用：operator[]，析构的时候，就用的delete[]

int main()
{unique_ptr<A[]> sp1(new A[10]);//unique_ptr<A> sp2(sp1);A* p = sp1.get();cout << p << endl;//if(sp1)//{ }//sp1->_a1++;//sp1->_a2--;sp1[0]._a1++;sp1[0]._a2++;return 0;
}

unique_ptr的底层实现:禁用拷贝构造和赋值：

// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr
// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
namespace bit
{template<class T>class unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}~unique_ptr() {if (_ptr){cout << "delete:" << _ptr << endl;delete _ptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}unique_ptr(const unique_ptr<T>& sp) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;private:T* _ptr;};
}

在某些场景，还是需要拷贝智能指针，因此库里还设计了一个只能指针，全能型：shared_ptr

shared_ptr（引入引用计数use_count，全能型）

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
std::shared_ptr文档

shared_ptr的原理：

是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

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

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

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

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

 示例：

	//就不会再报错shared_ptr<A[]> sp1(new A[10]);shared_ptr<A[]> sp2(sp1);

底层实现：

当有两个指针指向同一个空间，引用计数就为2，引用计数在拷贝的时候就会++计数，析构时就--计数，-到0就释放

use_count：

代参的构造在前面加了explicit，不支持隐式类型转换：

因为这里的本质是A*隐式类型转换给sp1，A

拷贝构造是noexcept保证不抛异常的

具体可以查文档

正常情况下我们都是通过上面的方式来构造智能指针的，有些地方会用make_shared(有一些类似于make_pair):        优势，内存碎片会少一点

使用：

	shared_ptr<A> sp3 = make_shared<A>();

A有多个参数的构造

	A(int a1, int a2):_a1(a1), _a2(a2){}

使用:

	shared_ptr<A> sp1(new A(1, 2));shared_ptr<A> sp3 = make_shared<A>(1, 2);

实现一个shared_ptr(重点)

引用计数如何设计

不能设置为静态的或者全局的

原因：

假如我有一个sp1、sp2共同管理A，现在又有一个sp3管理A，sp3也也需要一个引用计数

	shared_ptr<A> sp1(new A(1, 2));shared_ptr<A> sp2(sp1);shared_ptr<A> sp3 (new A(2, 2));

同一个类型，有多个资源，sp1、sp2需要有一个他们指向的空间的引用计数，sp3也单独需要一个他那个资源的引用计数，因此不能使用静态，一个计数是不能满足需求的。

解决方法：

将引用计数和资源绑在一起，指针指向资源的同时，也满足指向这个资源的引用计数：

我们需要的时候多个不同资源的引用计数

namespace pupu
{template<class T>class shared_ptr{public:shared_ptr(T* ptr):_ptr(ptr)//保存指针,_pcount(new int(1))//一个资源就初始化一个引用计数{ }//sp2(sp1) 拷贝构造shared_ptr(shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount){(*_pcount)++;}~shared_ptr(){ }private:T* _ptr;int* _pcount;};
}

示例：

#include "shared_ptr.h"int main()
{pupu::shared_ptr<A> sp1(new A(1, 2));pupu::shared_ptr<A> sp2(sp1);pupu::shared_ptr<A> sp3(new A(2, 2));return 0;
}

调试代码观察：

析构：

		~shared_ptr(){if (--(*_pcount) == 0)//现在的引用计数已经只有一个了{//释放最后一个管理的对象的资源delete _ptr;delete _pcount;}}

***最复杂的是赋值***：

调用release的情况有两种****（很重要）

•           如果这个对象还有其他的对象管就--计数
•           如果这个对象已经是最后一个管理资源的对象了，就释放

	 shared_ptr<T> operator=(shared_ptr<T>& sp) //sp = sp3{//一般情况下不要显示调用析构//两种情况,如果这个对象还有其他的对象管就--计数，// 如果这个对象已经是最后一个管理资源的对象了，就释放this->release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);return *this;}void release(){if (--(*_pcount) == 0)//现在的引用计数已经只有一个了{//释放最后一个管理的对象的资源delete _ptr;delete _pcount;}}

#include "shared_ptr.h"int main()
{pupu::shared_ptr<A> sp1(new A(1, 2));pupu::shared_ptr<A> sp2(sp1);pupu::shared_ptr<A> sp3(new A(2, 2));cout << sp1.use_count() << endl;pupu::shared_ptr<A> sp4(sp3);pupu::shared_ptr<A> sp5(sp4);cout << sp3.use_count() << endl;sp1 = sp3;return 0;
}

调试观察：

原来是sp1 、sp2指向同一个空间：sp3、sp4、sp5指向同一块空间

当运行到sp1 = sp3的时候：

处理自己给自己赋值的情况：这里判断到引用计数是1，因此再--，就直接sp6释放了，野指针了

	pupu::shared_ptr<A> sp6(new A(2, 2));pupu::shared_ptr<A> sp6 = sp6;

解决办法1：传统方式

要考虑sp3 = sp4，他们是两个不同的对象，但是管同一块资源：这里处理就是把计数-一下，又+一下

解决办法2：只要资源不是同一个

		 shared_ptr<T> operator=(shared_ptr<T>& sp) //sp = sp3{//sp3(sp3),不能再if (_ptr != sp._ptr){//一般情况下不要显示调用析构//两种情况,如果这个对象还有其他的对象管就--计数，// 如果这个对象已经是最后一个管理资源的对象了，就释放this->release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}

实现operator* ，operator->()

T& operator*()
{return *_ptr;
}
T* operator->()
{return _ptr;
}

每一个资源都会有一个引用计数，在堆上大量开小块的内存，会有内存碎片的问题，因此在构造的时候就传，让这个引用计数是从内存池传过去的，相对而言能缓解内存碎片的问题

这个问题可以使用make_shared去构造一个智能指针，他的底层和shared_ptr的区别，在底层上会将指针和引用计数放到一起。make_shared是在构造对象的时候，需要有对象类型A，以及初始化的值，里面使用初始化列表，不仅仅会构造A，还会构造引用计数，会多开四个字节，将对象和引用计数开到一起。将资源和计数绑到一起。

线程安全问题：

shared_ptr智能指针是线程安全的吗？
是的，引用计数的加减是加锁保护的。但是指向资源不是线程安全的
指向堆上资源的线程安全问题是访问的人处理的，智能指针不管，也管不了// 引用计数的线程安全问题，是智能指针要处理的

std::shared_ptr的线程安全问题

通过下面的程序我们来测试shared_ptr的线程安全问题。需要注意的是shared_ptr的线程安全分为两方面：
1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、--是需要加锁的，也就是说引用计数的操作是线程安全的。
2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

示例：假设我在这里面想要再写一个拷贝的，就会导致程序可能崩溃

mutex mtx;
void func(pupu::shared_ptr<list<int>> sp, int n)
{cout << sp.use_count() << endl;for (int i = 0; i < n; i++){pupu::shared_ptr<list<int>> copy1(sp);pupu::shared_ptr<list<int>> copy2(sp);pupu::shared_ptr<list<int>> copy3(sp);mtx.lock();sp->emplace_back(i);mtx.unlock();}
}
int main()
{pupu::shared_ptr<list<int>> sp1(new list<int>);cout << sp1.use_count() << endl;thread t1(func, sp1, 1000);thread t2(func, sp1, 2000);t1.join();t2.join();cout << sp1->size() << endl;cout << sp1.use_count() << endl;return 0;
}

同一个智能指针可能会给多个线程使用，引用计数不是线程安全的，两个线程在拷贝智能指针的过程中要++，智能指针对象析构，要--计数，保证引用计数的线程安全。

解决办法：

1.同一个资源使用同一个锁，加锁之后再++，加锁之后再--

• 因此我们应该将++--都改为原子操作：使用atomic
• 智能指针对象本身拷贝析构是线程安全的
• 底层引用计数加减是线程安全的
• 指向的资源访问的时候不是安全的

std::shared_ptr的循环引用

示例代码：

struct Node
{std::shared_ptr<Node> _next;std::shared_ptr<Node> _prev;int _val;~Node(){cout << "~Node" << endl;}
};int main()
{	//p1 p2是两个由智能指针管理的资源		std::shared_ptr<Node> p1(new Node);std::shared_ptr<Node> p2(new Node);//p1->_next = p2;//p2->_prev = p1;return 0;
}

两指针能正常释放：

我们将两节点关联起来

因此将_Node和_prev也定义为shared_ptr管理的指针：

std::shared_ptr<Node> _next;
std::shared_ptr<Node> _prev;

却出现内存泄漏：两个节点没有释放，程序直接退出

 只将p1的_next指向p2:能够正常退出

p1->_next = p2;

析构时：p2先析构，p2管理的资源的引用计数变成1，p1后析构，p1所管理的资源的引用计数变为0，_next的生命周期属于p1，因此析构p1的时候（还没有析构完成的时候），_next所指向的资源（引用计数变为0）会被先析构，再将p1析构完成。因此程序正确。

p1->_next = p2;

p2->_prev = p1;

这时候就会构成循环引用，shared_ptr最害怕的事情，程序完成，p2先析构，p2所指向的资源的引用计数减为1，资源现在由_next管理；p1析构，p1所指向的资源的引用计数减为1，资源现在由_prev管理。

这导致了释放逻辑是一个死循环

• p1和p2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
• 也就是说_next析构了，p2就释放了。
• 也就是说_prev析构了，p1就释放了。
• 但是_next属于p1的成员，p1释放了，_next才会析构，而p1由_prev管理，_prev属于p2成员，所以这就叫循环引用，谁也不会释放。

因此在使用shared_ptr的时候需要避免编写这样的办法。

解决办法：官方给了一个新的智能指针weak_ptr，让我们能够这样编写代码：

weak_ptr

原理就是，p1->_next = p2;和p2->_prev = p1;时weak_ptr的_next和_prev不会增加p1和p2的引用计数。

不支持RAII，不单独管理 资源，weak_ptr是专门用来辅助解决shared_ptr的循环引用问题的

解决办法：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了

struct Node
{std::weak_ptr<Node> _next;std::weak_ptr<Node> _prev;int _val;~Node(){cout << "~Node" << endl;}
};int main()
{	//p1 p2是两个由智能指针管理的资源		std::shared_ptr<Node> p1(new Node);std::shared_ptr<Node> p2(new Node);p1->_next = p2;//p2->_prev = p1;return 0;
}

expire判断是否过期：判断use_count是否为0，返回值0，代表没有过期。返回1代表过期。

定制删除器

如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题（ps：删除器这个问题我们了解一下）
这两种定义方式都是可以的

class A
{
public:A(int a1, int a2):_a1(a1), _a2(a2){}~A(){cout << "~A()" << endl;}
private:int _a1 = 1;int _a2 = 1;
};int main()
{	//std::shared_ptr<A> sp1(new A);std::shared_ptr<A[]> sp1(new A[10]);return 0;
}

但是不支持:

	std::shared_ptr<int> sp1((int*)malloc(4));

	std::shared_ptr<FILE> sp3(fopen("test.txt", "w"));

 因此我们使用定制删除器：

解决办法：传指针，传仿函数，lambda表达式（有解决办法的可以传给智能指针）：

template<class T>
struct FreeFunc {void operator()(T* ptr){cout << "free:" << ptr << endl;free(ptr);}
};
int main()
{	//std::shared_ptr<A[]> sp1(new A[10]);//用lambdastd::shared_ptr<A[]> sp1(new A[10], [](A* ptr) {delete[] ptr; });//仿函数std::shared_ptr<int> sp2((int*)malloc(4), FreeFunc<int>());//用lambdastd::shared_ptr<FILE> sp3(fopen("test.txt", "w"), [](FILE* ptr) { fclose(ptr); });return 0;
}

实现shared_ptr，定制删除器功能：

但是这样写会导致不能再支持不传定制删除器的构造智能指针：因为会调用nullptr的删除器，就会导致程序崩溃

	pupu::shared_ptr<A> sp4(new A);

解决办法：给_del一个缺省值 

function<void(T*)> _del = [](T* ptr) {delete ptr; };//进行一种回调，再析构的时候，再去调用我们制定好的传过来的删除器

测试代码：

int main()
{	//std::shared_ptr<A[]> sp4(new A[10]);//用lambdapupu::shared_ptr<A> sp1(new A[10], [](A* ptr) {delete[] ptr; });//仿函数pupu::shared_ptr<int> sp2((int*)malloc(4), FreeFunc<int>());//用lambdapupu::shared_ptr<FILE> sp3(fopen("test.txt", "w"), [](FILE* ptr) { fclose(ptr); });pupu::shared_ptr<A> sp4(new A);return 0;
}

  最后的精简版shared_ptr封装：

#pragma once#include<atomic>
#include<functional>
namespace pupu
{template<class T>class shared_ptr{public:shared_ptr(T* ptr):_ptr(ptr)//保存指针,_pcount(new atomic<int>(1))//一个资源就初始化一个引用计数{ }//定制删除器template<class D>shared_ptr(T* ptr, D del):_ptr(ptr),_pcount(new atomic<int>(1)),_del(del){}//sp2(sp1) 拷贝构造shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount){(*_pcount)++;}//sp6 = sp6		shared_ptr<T>& operator=(const shared_ptr<T>& sp) //sp = sp3{//sp3(sp3),不能再if (_ptr != sp._ptr){//一般情况下不要显示调用析构//两种情况,如果这个对象还有其他的对象管就--计数，// 如果这个对象已经是最后一个管理资源的对象了，就释放this->release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}void release(){if (--(*_pcount) == 0)//现在的引用计数已经只有一个了{//释放最后一个管理的对象的资源//delete _ptr;_del(_ptr);delete _pcount; }}~shared_ptr(){release();}int use_count(){return *_pcount;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;atomic<int>* _pcount;//指定返回值类型void和参数类型T*function<void(T*)> _del = [](T* ptr) {delete ptr; };//进行一种回调，再析构的时候，再去调用我们制定好的传过来的删除器};
}

结语：

       随着这篇博客接近尾声，我衷心希望我所分享的内容能为你带来一些启发和帮助。学习和理解的过程往往充满挑战，但正是这些挑战让我们不断成长和进步。我在准备这篇文章时，也深刻体会到了学习与分享的乐趣。    

         在此，我要特别感谢每一位阅读到这里的你。是你的关注和支持，给予了我持续写作和分享的动力。我深知，无论我在某个领域有多少见解，都离不开大家的鼓励与指正。因此，如果你在阅读过程中有任何疑问、建议或是发现了文章中的不足之处，都欢迎你慷慨赐教     。

        你的每一条反馈都是我前进路上的宝贵财富。同时，我也非常期待能够得到你的点赞、收藏，关注这将是对我莫大的支持和鼓励。当然，我更期待的是能够持续为你带来有价值的内容。