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

你好，此用户已存在

已于 2024-04-09 10:21:58 修改

阅读量958

点赞数 33

分类专栏： c++ 文章标签： c++

于 2024-02-23 17:27:46 首次发布

本文链接：https://blog.csdn.net/qq_58158950/article/details/136245398

版权

c++ 专栏收录该内容

63 篇文章 0 订阅

订阅专栏

本文详细介绍了智能指针的实现原理，包括如何将裸指针封装到栈上，通过浅拷贝和深拷贝解决资源管理和内存释放问题，以及不带引用计数的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(const CMasterPtr<T>&& p)
    {
        this->_ptr=p._ptr;
        p._ptr=nullptr;
    }

    CMasterPtr<T>& operator=(const 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

简易实现

#include<iostream>

#if 1
template<typename T>
class MyUniquePtr
{
public:
	MyUniquePtr(T* ptr):_ptr(ptr)
	{
		std::cout<<"constructor!"<<std::endl;
	}
	~MyUniquePtr()
	{
		std::cout<<"delete ptr"<<std::endl;
		delete _ptr;
		_ptr=nullptr;
	}
	MyUniquePtr(const MyUniquePtr&)=delete;
	MyUniquePtr<T> operator=(const MyUniquePtr&)=delete;
	MyUniquePtr(const MyUniquePtr&& msp)
	{
		std::cout<<"MyUniquePtr(const MyUniquePtr&& msp);!"<<std::endl;
		_ptr=msp._ptr;
	}
	MyUniquePtr<T> operator=(const MyUniquePtr&& msp)
	{
		std::cout<<"MyUniquePtr<T> operator=(const MyUniquePtr&& msp);~"<<std::endl;
		if(this!=&msp)
		{
			delete _ptr;
			_ptr=msp._ptr;
		}
		return *this;
	}

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

MyUniquePtr<int> uptest()
{
	MyUniquePtr<int> ptr(new int(50));
	return ptr;
}
#endif

void test()
{
#if 1
	MyUniquePtr<int> uptr1(new int(40));
	std::cout<<*uptr1<<std::endl;

	std::cout<<*uptest()<<std::endl;
	MyUniquePtr<int> res=uptest();
	std::cout<<*res<<std::endl;
#endif
}

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

实验结果

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

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

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

//引用计数管理类，管理的对象是一个裸指针
template <typename T>
class RefCnt
{
public:
    RefCnt(T* refPtr=nullptr):_refPtr(refPtr)
    {
        if(_refPtr)//如果所管理的指针不为空，就将该指针的引用计数置为1
        {
            _cnt=1;
        }
    }

    void addCnt()//添加引用计数
    {
        _cnt++;
    }

    int delCnt()//减少引用计数
    {
        return --_cnt;
    }

    int use_count()
    {
        return _cnt;
    }
private:
    T* _refPtr;
    int _cnt;
};

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

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

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

template <typename T>
class CMasterPtr
{
public:
    CMasterPtr(T* ptr=nullptr)
    :_ptr(ptr)
    {
        _refcnt=new RefCnt<T>(_ptr);//为裸指针初始化一个引用计数对象
        cout<<"construcor ptr"<<endl;
    }

    ~CMasterPtr()
    {
        cout<<"delete ptr"<<endl;
        //只有该指针的引用计数为0时才释放掉裸指针
        if(_refcnt->delCnt()==0)
        {
            delete _ptr;
            _ptr=nullptr;
        }
    }


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

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

    int use_count()
    {
        return _refcnt->use_count();
    }

private:
    T* _ptr;//指向内存资源
    RefCnt<T>* _refcnt;//指向引用计数资源
};

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

    CMasterPtr(const CMasterPtr<T>& p)
    :_ptr(p._ptr),_refcnt(p._refcnt)
    {
        if(_ptr)
        {
            _refcnt->addCnt();
        }
    }

    CMasterPtr<T>& operator=(const CMasterPtr<T>& p)
    {
        //处理自我赋值
        if(this==&p)
            return *this;
        
        //只有当引用计数为0时，才释放原来的裸指针
        if(_refcnt->delCnt()==0)
        {
            delete _ptr;
            _ptr=nullptr;
        }

        //接管资源
        _ptr=p._ptr;
        _refcnt->addCnt();
        _refcnt=p._refcnt;
        return *this;
    }

完整代码如下：


//引用计数管理类，管理的对象是一个裸指针
template <typename T>
class RefCnt
{
public:
    RefCnt(T* refPtr=nullptr):_refPtr(refPtr)
    {
        if(_refPtr)//如果所管理的指针不为空，就将该指针的引用计数置为1
        {
            _cnt=1;
        }
    }

    void addCnt()//添加引用计数
    {
        _cnt++;
    }

    int delCnt()//减少引用计数
    {
        return --_cnt;
    }

    int use_count()
    {
        return _cnt;
    }
private:
    T* _refPtr;
    int _cnt;
};

template <typename T>
class CMasterPtr
{
public:
    CMasterPtr(T* ptr=nullptr)
    :_ptr(ptr)
    {
        _refcnt=new RefCnt<T>(_ptr);//为裸指针初始化一个引用计数对象
        cout<<"construcor ptr"<<endl;
    }

    ~CMasterPtr()
    {
        cout<<"delete ptr"<<endl;
        //只有该指针的引用计数为0时才释放掉裸指针
        if(_refcnt->delCnt()==0)
        {
            delete _ptr;
            _ptr=nullptr;
        }
    }

    CMasterPtr(const CMasterPtr<T>& p)
    :_ptr(p._ptr),_refcnt(p._refcnt)
    {
        if(_ptr)
        {
            _refcnt->addCnt();
        }
    }

    CMasterPtr<T>& operator=(const CMasterPtr<T>& p)
    {
        //处理自我赋值
        if(this==&p)
            return *this;
        
        //只有当引用计数为0时，才释放原来的裸指针
        if(_refcnt->delCnt()==0)
        {
            delete _ptr;
            _ptr=nullptr;
        }

        //接管资源
        _ptr=p._ptr;
        _refcnt->addCnt();
        _refcnt=p._refcnt;
        return *this;
    }

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

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

    int use_count()
    {
        return _refcnt->use_count();
    }

private:
    T* _ptr;//指向内存资源
    RefCnt<T>* _refcnt;//指向引用计数资源
};

测试

void test()
{
    cout<<"使用shared_ptr"<<endl;
    shared_ptr<int> p1(new int(41));
    cout<<p1.use_count()<<endl;
    shared_ptr<int> p2(p1);
    cout<<p1.use_count()<<endl;
    cout<<p2.use_count()<<endl;

    cout<<endl<<"使用CMasterPtr："<<endl;
    CMasterPtr<int> mp1(new int(31));
    cout<<mp1.use_count()<<endl;
    CMasterPtr<int> mp2(mp1);
    cout<<mp1.use_count()<<endl;
    cout<<mp2.use_count()<<endl;
}

简易实现

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

运行结果