c++智能指针（unique_ptr、shared_ptr）的简易实现

已于 2024-10-19 23:19:05 修改
阅读量1k 收藏 19
点赞数 33
分类专栏： c++ 文章标签： c++
于 2024-02-23 17:27:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58158950/article/details/136245398
版权
本文详细介绍了智能指针的实现原理，包括如何将裸指针封装到栈上，通过浅拷贝和深拷贝解决资源管理和内存释放问题，以及不带引用计数的unique_ptr和带引用计数的shared_ptr的区别。
摘要由CSDN通过智能技术生成

智能指针的实现原理

  • 裸指针的内存开辟在堆上，程序员在使用时需要自己手动释放
  • 对于栈上的资源，编译器可以进行自动释放
  • 因此智能指针的实现思路就是，将裸指针放到栈上

具体而言，就是将裸指针作为数据成员，包装成一个类，如下所示：

template <typename T>
class CMasterPtr
{
public:
    CMasterPtr(T* ptr=nullptr):_ptr(ptr)
    {
        cout<<"construcor ptr"<<endl;
    }
    ~CMasterPtr()
    {
        cout<<"delete ptr"<<endl;
        delete _ptr;
    }
private:
    T* _ptr;
};

这样，如下所示，当我们创建这个智能指针对象时，这个对象资源就被放在了栈上，当该对象离开其作用域时，编译器便会自动调用该对象的析构函数，释放掉裸指针的内存。

void test()
{    
    CMasterPtr<int> masterPtr(new int(10));
}

而为了让智能指针支持普通指针的运算，需要对该类进行运算符重载，如下：

template <typename T>
class CMasterPtr
{
public:
    CMasterPtr(T* ptr=nullptr):_ptr(ptr)
    {
        cout<<"construcor ptr"<<endl;
    }
    ~CMasterPtr()
    {
        cout<<"delete ptr"<<endl;
        delete _ptr;
    }

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

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

private:
    T* _ptr;
};

测试代码如下：

class Test{
public:
    void test()
    {
        cout<<"this is ptr test"<<endl;
    }
};

void test()
{
    CMasterPtr<int> masterPtr(new int(10));
    cout<<*masterPtr<<endl;
    *masterPtr=20;
    cout<<*masterPtr<<endl;

    CMasterPtr<Test> masterPtr2(new Test);
    masterPtr2->test();
    
}

智能指针类的浅拷贝问题

以上，虽然我们通过将一个裸指针包装成一个类，解决了指针需要手动释放的问题，但由于指针本身的浅拷贝问题，使得该类仍旧无法满足我们的使用需要。

如下所示，由于一个类默认的拷贝构造函数和拷贝赋值运算符属于浅拷贝，因此，当下述代码运行结束后，就会带来指针所指向内存的二次释放问题。

void test()
{
    CMasterPtr<int> p1(new int(10));
    CMasterPtr<int> p2(p1);
    p2=p1;
}

一般而言，我们以往处理指针的浅拷贝问题的解决办法是进行深拷贝，也就是如下处理。

    CMasterPtr(const CMasterPtr<T>& p)
    {
        this->_ptr=new T(*p._ptr);
    }

    CMasterPtr<T>& operator=(const CMasterPtr<T>& p)
    {
        //处理自我赋值问题
        if(this==*p)
            return *this;
        //释放原内存
        delete _ptr;
        //修改原内存的值
        this->_ptr=new T(*p._ptr);
        return *this;
    }

但是这样的深拷贝带来的问题是，用户使用的两个指针指向的不同的内存空间。

然而，一般情况下，用户的需求是，当修改p2的值时，p1的值也会发生相应改变。但是这样的深拷贝使得两个指针指向的内存空间不一样，无法满足用户的需求。

如下所示，p1的值原来是20，用户使用p2拷贝了p1，并修改p2，希望修改p2后p1的值也发生相应改变，但深拷贝的结果违背了这种需求。

void test()
{
    CMasterPtr<int> p1(new int(10));
    CMasterPtr<int> p2(p1);

    *p2=20;
    cout<<*p1<<endl;
}

不带引用计数的智能指针实现

针对以上问题，不带引用计数的智能指针的实现方法有三个。

  • 直接将p1指向的资源转交给p2，如下图所示，这也是auto_ptr的处理
  • 直接显式的禁止拷贝和赋值，如下所示，这也是scoped_ptr的处理 
        CMasterPtr(const CMasterPtr<T>& p)=delete
    CMasterPtr& operator=(const CMasterPtr<T>& p)=delete
  • 显式禁止拷贝和赋值，但是提供右值引用的拷贝和赋值，这是unique_ptr的处理 
        CMasterPtr(CMasterPtr<T>&& p)
    {
        this->_ptr=p._ptr;
        p._ptr=nullptr;
    }

    CMasterPtr<T>& operator=(CMasterPtr<T>&& p)
    {
        if(this==&p)
            return *this;
        
        delete _ptr;
        _ptr=p._ptr;
        p._ptr=nullptr;
    }

    值得说明的是，unique_ptr的处理操作使得能够让一个函数返回unique_ptr类型的返回值，而scoped_ptr却不能，至于auto_ptr，由于其直接转移指针资源的所有权，容易让代码出现问题，因此使用频率更加少，故而推荐大家使用unique_ptr

简易实现

（2024.10.19修改）

#include<iostream>

template<typename T>
class UniquePtr{
public:
    //定义构造函数
	explicit UniquePtr(T* ptr):ptr_(ptr){}
	//定义析构函数
    ~UniquePtr(){
		delete ptr_;
		ptr_=nullptr;
	}
    //禁止拷贝和赋值
	UniquePtr(const UniquePtr&)=delete;
	UniquePtr& operator=(const UniquePtr&)=delete;
    //允许移动构造和移动赋值
	UniquePtr(UniquePtr&& rhs) noexcept :ptr_(rhs.ptr_){
		rhs.ptr_=nullptr;
	}
	UniquePtr& operator=(UniquePtr&& rhs){
		if(this!=&rhs){
			delete ptr_;
			ptr_=rhs.ptr_;
			rhs.ptr_=nullptr;
		}
		return *this;
	}

	T* release()  {
		T* tmp=ptr_;
		ptr_=nullptr;
		return tmp;
	}
    //类型转换函数
	template<typename U>
	UniquePtr(UniquePtr<U>&& rhs) noexcept :ptr_(rhs.release()){}
	//重载指针操作
	T& operator*() const{
		return *ptr_;
	}

	T* operator->() const{
		return ptr_;
	}
    //获取裸指针
	T* get() const{
		return ptr_;
	}

private:
	T* ptr_;
};

class Base{
public:
	char* str="hello";
protected:
	int num;
};

class Derive:public Base{
private:
	double  num1;
};

void Test(){
	UniquePtr<int> sp1(new int(42));
	std::cout<<*sp1<<std::endl;
	UniquePtr<int> sp2(std::move(sp1));
	
	UniquePtr<double> sp3(new double(3.14));
	std::cout<<*(sp3)<<std::endl;
	UniquePtr<double> sp4=(std::move(sp3));

	UniquePtr<Base> bp1(new Base);
	std::cout<<bp1->str<<std::endl;
	UniquePtr<Derive> dp1(new Derive);
	bp1=std::move(dp1);
}

int main()
{
	Test();
	return 0;
}

实验结果

带引用计数的智能指针实现

该节我们实现shared_ptr智能指针的实现

首先，我们创建一个引用计数类，该类用于管理指针所指内存的计数，代码如下：

class RefCnt{
public:
	explicit RefCnt(int ref_cnt=1):ref_cnt_(ref_cnt){}
	int AddCnt(){
		return ++ref_cnt_;
	}

	int DelCnt(){
		return --ref_cnt_;
	}

	int get_cnt(){
		return ref_cnt_;
	}

private:
	int ref_cnt_;
};

在最开始智能指针的实现原理一节，我们说到，智能指针的实现是通过将一个裸指针封装成一个类，由于一个类在栈上，因此当作用域结束时可以自行调用析构函数释放掉其管理的数据成员（也就是我们的封装的裸指针），从而解决了堆上裸指针的手动释放问题。

而对于shared_ptr而言，其拷贝和赋值都将引起其管理资源引用计数的变化，只有当其所管理的资源的引用计数为0时，才释放掉指针。

因此，我们需要为CMasterPtr增加一个数据成员，专门用于管理CMasterPtr中裸指针的引用计数。如下：

#include<iostream>


template<typename T>
class SharedPtr{
public:
	SharedPtr(T* ptr=nullptr):ptr_(ptr){
		ref_cnt_=new RefCnt();
	}
	~SharedPtr(){
        //只有当指针所指向内存的引用计数为0才释放内存，否则就仅仅减少引用计数
		if(ref_cnt_->DelCnt()<=0){
			delete ptr_;
			delete ref_cnt_;
			ptr_=nullptr;
			ref_cnt_=nullptr;
		}
		
	}
private:
	T* ptr_;
	RefCnt* ref_cnt_;
};

接下来，我们重写CMasterPtr的拷贝构造函数和赋值运算符

#include<iostream>

template<typename T>
class SharedPtr{
public:
	SharedPtr(T* ptr=nullptr):ptr_(ptr){
		ref_cnt_=new RefCnt();
	}
	~SharedPtr(){
		if(ref_cnt_->DelCnt()<=0){
			delete ptr_;
			delete ref_cnt_;
			ptr_=nullptr;
			ref_cnt_=nullptr;
		}
		
	}
	SharedPtr(const SharedPtr& rhs):ptr_(rhs.ptr_),ref_cnt_(rhs.ref_cnt_){
		ref_cnt_->AddCnt();
	}
	SharedPtr& operator=(const SharedPtr& rhs){
		if(this!=&rhs){
            //只有当指针所指向对象的引用计数小于等于0时才销毁被赋值对象所指的内存空间，否则就只是减少引用计数
			if(ref_cnt_->DelCnt()<=0){
				delete ptr_;
				delete ref_cnt_;
				ptr_=nullptr;
				ref_cnt_=nullptr;
			}
            //做赋值操作
			ptr_=rhs.ptr_;
			ref_cnt_=rhs.ref_cnt_;
            //给被复制的对象所指向的内存引用计数加一
			ref_cnt_->AddCnt();

		}
		return *this;
	}
private:
	T* ptr_;
	RefCnt* ref_cnt_;
};

同理，增加移动构造函数和移动赋值运算符

 

代码如下：

#include<iostream>

//引用计数管理类
class RefCnt{
public:
	explicit RefCnt(int ref_cnt=1):ref_cnt_(ref_cnt){}
	int AddCnt(){
		return ++ref_cnt_;
	}

	int DelCnt(){
		return --ref_cnt_;
	}

	int get_cnt(){
		return ref_cnt_;
	}

private:
	int ref_cnt_;
};

template<typename T>
class SharedPtr{
public:
	SharedPtr(T* ptr):ptr_(ptr){
		ptr_ref_cnt_=new RefCnt();
	}
	~SharedPtr(){
        //析构函数，只有当指针所指向的内存引用计数为0时，才释放空间
		if(ptr_ref_cnt_->get_cnt()==0){
			delete ptr_;
			delete ptr_ref_cnt_;
			ptr_=nullptr;
			ptr_ref_cnt_=nullptr;
		}
	}

	SharedPtr(const SharedPtr& rhs):ptr_(rhs.ptr_),ptr_ref_cnt_(rhs.ptr_ref_cnt_){
		ptr_ref_cnt_->AddCnt();
	}

	SharedPtr& operator=(const SharedPtr& rhs){
		if(this!=&rhs){
			//清理原空间
			delete ptr_;
			//数据赋值
			ptr_=rhs.ptr_;
			ptr_ref_cnt_=rhs.ptr_ref_cnt_;
			//增加当前的内存的引用计数
			ptr_ref_cnt_->AddCnt();
		}
		return *this;
	}
	
	int use_count() const {
		return ptr_ref_cnt_->get_cnt();
	}
private:
	T* ptr_;
	RefCnt* ptr_ref_cnt_;
};

测试


void Test(){	
	SharedPtr<int> sp1(new int(42));
	std::cout<<sp1.use_count()<<std::endl;
	SharedPtr<int> sp2(sp1);
	std::cout<<sp1.use_count()<<std::endl;
	std::cout<<sp2.use_count()<<std::endl;
	SharedPtr<int> sp3=sp2;
	std::cout<<sp1.use_count()<<std::endl;
	std::cout<<sp2.use_count()<<std::endl;
	std::cout<<sp3.use_count()<<std::endl;
}

int main(){
	Test();
	return 0;
}

简易实现

#include<iostream>

template<typename T>
class MySharedPtr
{
public:
	MySharedPtr(T* ptr=nullptr):_ptr(ptr)
	{
		std::cout<<"contrcutor!"<<std::endl;
		if(_ptr) 
		{
			_cnt=new int(1);
		}else{
			_cnt=new int(0);
		}
	}

	~MySharedPtr()
	{
		std::cout<<"delete ptr"<<std::endl;
		if(--(*_cnt)==0)
		{
			delete _ptr;
			delete _cnt;
			_ptr=nullptr;
			_cnt=nullptr;
		}
	}

	MySharedPtr(const MySharedPtr& msp):_ptr(msp._ptr),_cnt(msp._cnt)
	{
		std::cout<<"MySharedPtr(const MySharedPtr& msp);"<<std::endl;
		if(_ptr)
		{
			++(*_cnt);
		}
	}

	MySharedPtr& operator=(const MySharedPtr& msp)
	{
		std::cout<<"MySharedPtr& operator=(const MySharedPtr& msp);"<<std::endl;
		if(this!=&msp)
		{
			if(--(*_cnt)<=0)
			{
				delete _ptr;
				delete _cnt;
				_ptr=nullptr;
				_cnt=nullptr;
			}

			_ptr=msp._ptr;
			_cnt=msp._cnt;
			++(*_cnt);
		}
		return *this;
	}

	T& operator*()const
	{
		return *_ptr;
	}

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

	int use_count()const{
		return *_cnt;
	}
private:
	T* _ptr;
	//引用计数，此处必须使用指针类型，这样拷贝构造函数才能对同一个资源进行计数管理
	int* _cnt;
};

void test()
{
	MySharedPtr<int> ptr1(new int(10));
	MySharedPtr<int> ptr2(ptr1);
	std::cout<<ptr2.use_count()<<std::endl;
	std::cout<<ptr1.use_count()<<std::endl;

	MySharedPtr<int> ptr3;
	MySharedPtr<int> ptr4;
	std::cout<<ptr3.use_count()<<std::endl;
	ptr3=ptr2;
	std::cout<<ptr2.use_count()<<std::endl;
	std::cout<<ptr1.use_count()<<std::endl;
	std::cout<<ptr3.use_count()<<std::endl;

}

int main()
{
	test();
	return 0;
}

 运行结果

你好，此用户已存在
关注
专栏目录
C++ unique_ptr weak_ptr shared_ptr auto_ptr智能指针.doc
07-23
在 C++ 中，有四种智能指针：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr，每种智能指针都有其特点和使用场景。 一、auto_ptr auto_ptr 是 C++98 中引入的智能指针，它可以自动释放动态分配的内存。但是，auto_...
MyString（智能指针与深拷贝浅拷贝）
最新发布
2302_80090192的博客
08-03 379
首先进入主函数会给主函数分配一个栈，然后向下执行到func函数，会给func函数分配一个栈，然后给形参x分配一个空间，x的值为10，然后我们定义了一个ip对象（这里的ip不是指针，看清楚），然后给ip分配一个空间，对象ip中会有一个成员ptr，然后我们进入Int的构造函数（首先从堆区申请一个空间来构建Int对象，并初始化为10，然后把地址给ip中的ptr指针），这是ptr指向Int对象。然后我们 调动->的重载。
学习-＞C++篇十九：四种智能指针及其实现
u014801954的博客
12-21 1338
目录 为什么需要智能指针？ 什么是内存泄露？ 如何避免内存泄露？ 什么是RAII？ RAII有什么用？ 智能指针的原理是什么？ C++的智能指针有哪些？ auto_ptr unique_ptr shared_ptr weak_ptr
C++：智能指针实现
tecoes的博客
08-02 315
weak_ptr不参与资源的管理和释放，可以使用shared_ptr对象来构造weak_ptr对象，但是不能直接使用指针来构造weak_ptr对象，在weak_ptr中，也没有operator*函数和operator->成员函数，不具有一般指针的行为，因此，weak_ptr严格意义上并不是智能指针，weak_ptr的出现，就是为了解决shared_ptr的循环引用问题。但是，只有对象本身析构，它的成员才会析构，因此n1和n2彼此制约对方的析构，最终n1和n2的资源都无法释放，造成了内存泄漏。
C++智能指针原理与实现
geek！
09-10 1276
如果一块内存被shared_ptr和weak_ptr同时引用，当所有shared_ptr析构了之后，不管还有没有weak_ptr引用该内存，内存也会被释放。unique_ptr在auto_ptr的基础上直接禁用了拷贝构造和赋值重载(delete)，从而避免了auto_ptr在使用上容易出错的问题，但是没有了这两个函数，对于用户非常不便。weak_ptr是一个弱引用，它是为了配合shared_ptr而引入的一种智能指针，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期，也就是说，它。
C++语法——详解智能指针的概念、实现原理、缺陷
weixin_61857742的博客
12-09 2367
最初的智能指针是C++98提出来的auto_ptr，不过因为使用时缺陷很大，Beman G.Dawes（C++委员会成员之一）所成立的boost社区（专门面向C++程序员，提供许多免费好用的自制库）贡献了scoped_ptr、shared_ptr、weak_ptr被C++11采纳，修改为官方的unique_ptr、shared_ptr、weak_ptr。，即只能有一个指针指向申请的资源空间，不存在两个指针同时指向一个空间，可以说这个就是C++11中对auto_ptr的改进，将它作为智能指针的一种形式。
c++智能指针实现
xianzhetime的博客
04-26 337
已知面试官常问c++大型程序内存泄露怎么办，同学们通常会回答使用智能指针，智能指针可以避免使用new来初始化对象带来的delete问题，智能指针的实现思路是raii思想。unique_ptr传入函数作为参数时无法通过值传递，但可以通过引用传递，另外，可以通过get方法获得裸指针传入，也可以使用move语义将智能指针交给函数管理。共享指针即一个对象可以由多个指针托管，当所有托管指针都不再托管该对象时，对象才会被析构，共享指针可以通过。与unique_ptr不同的是，shared_ptr有。
C++ 智能指针简易实现
PX1525813502的博客
05-23 1528
C++ 智能指针的实现原理(简易版)
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
本文主要讨论了三种智能指针：`shared_ptr`、`unique_ptr`和`weak_ptr`。 首先，`shared_ptr`是引用计数型智能指针，它维护了一个内部的引用计数，用于跟踪有多少个`shared_ptr`实例指向同一对象。当创建一个新的`...
C++11智能指针中的 unique_ptr实例详解
08-19
《C++11智能指针中的unique_ptr实例详解》 C++11引入了智能指针，其中的unique_ptr是一种非常重要的智能指针类型。它以其“独特性”和“唯一性”为特点，提供了对对象所有权的严格管理，确保了资源在不再需要时能够...
浅析Boost智能指针:scoped_ptr shared_ptr weak_ptr
09-05
【Boost智能指针详解：scoped_ptr、shared_ptr与weak_ptr】 智能指针是C++中用来自动管理动态分配内存的对象，它可以确保在适当的时间释放内存，以防止内存泄漏。Boost库提供了一组智能指针类型，包括scoped_ptr、...
智能指针的实现
顺其自然~专栏
05-20 1495
内存有四块：全局区、栈区、堆区、代码区。 全局区存放着的是等到程序结束前才会释放里面的数据 代码区是存放着编译后的二进制的0和1 栈区：压栈、出栈，会自动管理释放 堆区：new出来的需要手动delete，由程序员管理 而智能指针的实现是利用了栈区和堆区的存储特性来实现的。 一、对象开辟在栈区，析构函数会自动释放内存 class Person{ public: Person(int age) { this->m_age = age; } ~Person() { co..
C++智能指针的实现与使用(详解)
田螺姑娘的博客
04-05 3482
C++智能指针的实现与使用(详解) 智能指针介绍 缘起 C++指针的实际问题 分配内存忘记释放，导致内存泄漏 有指针引用时释放内存，导致其它指针非法访问异常 一些对象的声明周期难以明确 办法 首先重载运算符*、->、[]、=使得一个类具有指针的操作 其次，使用模板编程，使得一个模板类可以接入各种类型 最后，自己管理内存。 使用方法 get、swap、unique、use_count、reset、make_shared(模板方法) 注意事项 智能指针不是线程安全的。 #include <ios
C++智能指针的简单实现
bdn_nbd的博客
11-17 227
C++智能指针简单实现
C++智能指针讲解及模拟实现
cdzg_zzk的博客
08-05 1292
C++智能指针详解及模拟实现
【C++实现智能指针】
weixin_43273308的博客
06-21 411
智能指针，C++实现shared_ptr和unique_ptr
【C++】【原创】从0开始实现智能指针
zyhcore的博客
05-29 378
智能指针：能够保证资源的绝对释放，里面默认都是delete ptr释放资源的但不是所有的资源都是能够通过delete释放的，毕竟资源那么多种类比如我用智能指针托管数组的话，那delete就不行，得用delete[]再比如我让它管理的不是内存资源，而是文件资源，那释放文件也绝对不可能用delete释放的所以在我们除了智能指针在堆内存外，怎么正确指导智能指针来正确删除呢先讲讲智能指针内部是咋回事吧unique_ptr shared_ptr 一个不带计数，一个带计数他们两个都是可以带自定义删除器的。
C++之智能指针
zdlynj的博客
10-25 997
智能指针实例化的对象在其生命周期结束时，默认是以delete的方式将空间释放，这是不太合适的，因为我们并不是只是以new的方式申请到的内存空间，也可能是以new[]的方式申请到多个空间，或是一个文件指针。使用了智能指针后，在Func中，即使div的调用抛出了异常，直接跳到了catch位置，sp1和sp2的空间也能够释放。所谓智能指针，它的本质就需要像一个指针一样去使用。_next 和 _prev 是 weak_ptr 时，它不参与资源的释放管理，但是可以访问和修改资源，且不增加计数，不存在循环引用的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值