实现简单的shared_ptr

已于 2022-11-29 10:00:57 修改
阅读量612 收藏 5
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-09-19 16:05:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42500831/article/details/126802395
版权

文章目录

类图如下：
在这里插入图片描述

shared_ptr和weak_ptr都有一个基类Ptr_base，Ptr_base有指向资源的指针_Ptr和指向引用计数的指针_Rep

引用计数对象Ref_count封装了对资源以及引用计数对象的释放操作，Ref_count也有一个基类Ref_count_base，封装了对引用计数_Uses、_Weaks，以及对_Uses、_Weaks的++、--操作

My_Ref_count_base

My_Ref_count_base类是一个抽象类：

  • 有两个计数器变量：_Uses供shared_ptr计数用，_Weaks供weak_ptr指针计数用
  • 保证线程安全：_Uses和_Weaks加1减1使用原子操作
  • 如果_Uses值为0，删除资源对象，调用_Destroy()
  • 如果_Weaks的值为0，删除引用计数器对象，也就是删除自己，调用Delete_this()
  • 两个纯虚函数：_Destroy()删除资源对象；Delete_this()删除引用计数器对象本身
class My_Ref_count_base {
	public:
		// 派生类无法进行拷贝构造和赋值
		My_Ref_count_base(const My_Ref_count_base&) = delete;
		My_Ref_count_base& operator=(const My_Ref_count_base&) = delete;
		// 虚析构，多态释放
		virtual ~My_Ref_count_base(){};

		void _Incref() { _Uses += 1; }
		void _Incwref() { _Weaks += 1; }
		
		void _Decref() {
			if (--_Uses == 0) {
				// _Uses == 0，删除资源，并将_Weaks--
				_Destroy();
				_Decwref();
			}
		}
		
		void _Decwref() {
			if (--_Weaks == 0) {
				_Delete_this();
			}
		}

		long _use_count() const {
			return _Uses;
		}

	private:
		virtual void _Destroy() = 0;      // 删除资源对象
		virtual void _Delete_this() = 0;  // 删除引用计数器对象本身

		std::atomic<int> _Uses{ 1 };
		std::atomic<int> _Weaks{ 1 };

	protected:
		My_Ref_count_base() = default;
};

My_Ref_count

My_Ref_count_base的第一个派生类是My_Ref_count，无删除器的引用计数类型，它是能够实例化对象的引用计数类型，使用的时候都是用的My_Ref_count，只有把指针类型声明成My_Ref_count_base

  • 数据成员_Ptr，指向资源对象
  • 实现了My_Ref_count_base抽象基类中的纯虚函数
template<class T>
class My_Ref_count : public My_Ref_count_base{
public:
	My_Ref_count(T* Px)
		: My_Ref_count_base()
		, _Ptr(Px)
	{}
private:
	// 删除资源对象
	virtual void _Destroy() {
		delete _Ptr;
	}

	// 删除引用计数器对象本身
	virtual void _Delete_this() {
		delete this;
	}
private:
	T* _Ptr; // 指向资源对象
};

My_Ptr_base

该类是My_shared_ptr和My_weak_ptr的共同基类

  • 有两个指针成员，分别是element_type* _Ptr和My_Ref_count_base * _Rep
  • _Ptr指向资源地址，_Rep指向引用计数器对象
template<class T>
class My_Ptr_base {
public:
	using element_type = T;
	My_Ptr_base(const My_Ptr_base&) = delete;
	My_Ptr_base& operator=(const My_Ptr_base&) = delete;

	element_type* get() const {
		return _Ptr;
	}

	long use_count() const {
		return _Rep == nullptr ? 0 : _Rep->_use_count();
	}

protected:
	My_Ptr_base() = default;
	~My_Ptr_base() = default;

	// const My_Ptr_base* this
	void Incref() const {
		if (nullptr != _Rep) {
			_Rep->_Incref();
		}
	}

	void Inwcref() const {
		if (nullptr != _Rep) {
			_Rep->_Incwref();
		}
	}

	void Decref() const {
		if (nullptr != _Rep) {
			_Rep->_Decref();
		}
	}

	void Decwref() const {
		if (nullptr != _Rep) {
			_Rep->_Decwref();
		}
	}

	void Swap(My_Ptr_base& right) {
		std::swap(_Ptr, right._Ptr);
		std::swap(_Rep, right._Rep);
	}
	
	void _Copy_construct_from(const My_shared_ptr<T>& left) {
		if (this == &left) {
			return;
		}
		this->_Ptr = left._Ptr;
		this->_Rep = left._Rep;
		this->Incref();
	}

	// 移动构造的参数不要用const，否则不能修改参数的成员
	void _Move_construct_from(My_shared_ptr<T>&& right) {
		if (this == &right) {
			return;
		}
		this->_Ptr = right._Ptr;
		this->_Rep = right._Rep;
		right._Ptr = nullptr;
		right._Rep = nullptr;
	}
protected:
	element_type* _Ptr{nullptr};
	My_Ref_count_base* _Rep{ nullptr };
};

My_shared_ptr

template<class T>
class My_shared_ptr : public My_Ptr_base<T> {
public:
	explicit My_shared_ptr() = default;
	// explicit My_shared_ptr(nullptr_t) = default;
	explicit My_shared_ptr(T * Px) {
		this->_Ptr = Px;                              // 资源
		this->_Rep = new My_Ref_count<T>(Px);         // 引用计数器
	}

	// My_shared_ptr的拷贝构造，就是需要将资源指针_Ptr和引用计数_Rep指针赋值，然后引用计数++
	My_shared_ptr(const My_shared_ptr<T>& left) {
		this->_Copy_construct_from(left);
	}

	My_shared_ptr(My_shared_ptr<T>&& right) {
		this->_Move_construct_from(std::move(right)); // right为左值引用变量，本身是一个左值，需要再转换一次
	}

	~My_shared_ptr() {
		this->Decref();
	}

	void swap(My_shared_ptr& right) {
		this->Swap(right);
	}
	// 将当前对象置空
	void reset() {
		My_shared_ptr().swap(*this);    // swap后，this有了临时对象的资源，即被置空了，临时对象有了this的资源，出作用域被析构
	}

	void reset(T* Px) {
		My_shared_ptr(Px).swap(*this);
	}

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

	explicit operator bool() const {
		return get() != nullptr;
	}


private:
	using My_Ptr_base<T>::get;
};

完整代码：


class My_Ref_count_base;

template<class T>
class My_Ref_count;

template<class Resource, class Dx>
class My_Ref_count_resource;

template<class T>
class My_Ref_base;

template<class T>
class My_shared_ptr;

template<class T>
class My_weak_ptr;

// 引用计数对象的基类
class My_Ref_count_base {
	public:
		// 派生类无法进行拷贝构造和赋值
		My_Ref_count_base(const My_Ref_count_base&) = delete;
		My_Ref_count_base& operator=(const My_Ref_count_base&) = delete;
		virtual ~My_Ref_count_base() {};        // 虚析构，多态释放

		void _Incref() { _Uses += 1; }
		void _Incwref() { _Weaks += 1; }

		void _Decwref() {
			if (--_Weaks == 0) {
				_Delete_this();
			}
		}

		void _Decref() {
			if (--_Uses == 0) {
				// _Uses == 0，删除资源，并将_Weaks--
				_Destroy();
				_Decwref();
			}
		}

		long _use_count() const {
			return _Uses;
		}

	private:
		virtual void _Destroy() = 0;      // 删除资源对象
		virtual void _Delete_this() = 0;  // 删除引用计数器对象本身

		std::atomic_int _Uses{ 1 };
		std::atomic_int _Weaks{ 1 };

	protected:
		My_Ref_count_base() = default;
};

// 无删除器的引用计数类型
template<class T>
class My_Ref_count : public My_Ref_count_base{
public:
	My_Ref_count(T* Px)
		: My_Ref_count_base()
		, _Ptr(Px)
	{}
private:
	// 删除资源对象
	virtual void _Destroy() {
		delete _Ptr;    // 删除单个对象，而不是一组对象
	}

	// 删除引用计数器对象本身
	virtual void _Delete_this() {
		delete this;
	}
private:
	T* _Ptr;
};

template<class T>
class My_Ptr_base {
public:
	using element_type = T;

	My_Ptr_base(const My_Ptr_base&) = delete;
	My_Ptr_base& operator=(const My_Ptr_base&) = delete;

	element_type* get() const {
		return _Ptr;
	}

	long use_count() const {
		return _Rep == nullptr ? 0 : _Rep->_use_count();
	}

protected:
	My_Ptr_base() = default;
	~My_Ptr_base() = default;

	// const My_Ptr_base* this
	void Incref() const {
		if (nullptr != _Rep) {
			_Rep->_Incref();
		}
	}

	void Inwcref() const {
		if (nullptr != _Rep) {
			_Rep->_Incwref();
		}
	}

	void Decref() const {
		if (nullptr != _Rep) {
			_Rep->_Decref();
		}
	}

	void Decwref() const {
		if (nullptr != _Rep) {
			_Rep->_Decwref();
		}
	}

	void Ptr_base_Swap(My_Ptr_base& right) {
		std::swap(_Ptr, right._Ptr);
		std::swap(_Rep, right._Rep);
	}

protected:
	void _Copy_construct_from(const My_shared_ptr<T>& left) {
		if (this == &left) {
			return;
		}
		this->_Ptr = left._Ptr;
		this->_Rep = left._Rep;
		this->Incref();
	}

	// 因为weak_ptr可以通过weak_ptr和shared_ptr进行拷贝构造，所有这里形参用My_Ptr_base，可以接收weak_ptr和shared_ptr实参
	void _Weak_Copy_construct_from(const My_Ptr_base<T>& left) {
		if (this == &left) {
			return;
		}
		// weak_ptr只关心引用计数器是否存活
		if (nullptr != left._Rep) {
			this->_Ptr = left._Ptr;
			this->_Rep = left._Rep;
			this->Inwcref();
		}
	}

	// 移动构造的参数不要用const，否则不能修改参数的成员
	void _Move_construct_from(My_Ptr_base<T>&& right) {
		if (this == &right) {
			return;
		}
		this->_Ptr = right._Ptr;
		this->_Rep = right._Rep;
		right._Ptr = nullptr;
		right._Rep = nullptr;
	}

protected:
	element_type* _Ptr{nullptr};
	My_Ref_count_base* _Rep{ nullptr };
};

template<class T>
class My_shared_ptr : public My_Ptr_base<T> {
public:
	explicit My_shared_ptr() = default;
	// explicit My_shared_ptr(nullptr_t) = default;
	explicit My_shared_ptr(T * Px) {
		this->_Ptr = Px;                              // 资源
		this->_Rep = new My_Ref_count<T>(Px);         // 引用计数器
	}

	// My_shared_ptr的拷贝构造，就是需要将资源指针_Ptr和引用计数_Rep指针赋值，然后引用计数++
	My_shared_ptr(const My_shared_ptr<T>& left) {
		this->_Copy_construct_from(left);
	}

	My_shared_ptr(My_shared_ptr<T>&& right) {
		this->_Move_construct_from(std::move(right)); // right为左值引用变量，本身是一个左值，需要再转换一次
	}

	My_shared_ptr(const My_weak_ptr<T>& left) {
		this->_Copy_construct_from(left);
	}

	~My_shared_ptr() {
		this->Decref();
	}

	void swap(My_shared_ptr& right) {
		this->Swap(right);
	}
	// 将当前对象置空
	void reset() {
		My_shared_ptr().swap(*this);                // swap后，this有了临时对象的资源，即被置空了，临时对象有了this的资源，出作用域被析构
	}

	void reset(T* Px) {
		My_shared_ptr(Px).swap(*this);
	}

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

	explicit operator bool() const {
		return get() != nullptr;
	}


private:
	using My_Ptr_base<T>::get;
};

直接使用构造函数和使用make_shared的区别

在这里插入图片描述
手动调用new缺陷： 如果 shared_ptr sp(new int(10)) 这行代码中的new int(10) 执行成功了，而shared_ptr的构造函数执行失败了，就不会有引用计数的_Ref_count对象，就意味着不存在shared_ptr对象，就不会调用shared_ptr的析构函数，那我们new出来的堆区资源也就不会释放了

手动调用new好处： 如果我们手动调用构造函数生成shared_ptr对象，资源和引用计数对象是分开存放在堆区的，当Uses_为0，Weaks_不为0时，会把资源释放，而不释放引用计数对象，即相对于使用make_shared资源对象可以提前释放。只有Uses_和Weaks_同时为0，引用计数对象才会被释放。

在这里插入图片描述
make_shared优点：

  • make_shared把资源和引用计数的对象放在连续的空间中，只需要new一次，解决了上面的问题。new失败没有资源泄露，new成功析构函数会释放资源
  • 根据程序运行的局部性原理，将资源对象和引用计数器对象放在一起比分开放，能减少一半的cache miss

make_shared缺点：

  • 由于使用make_shared分配的资源空间和引用计数对象的空间是连续的，是一次性申请的，也需要一次性释放。所以对于make_shared new出来的内存，就算引用计数_Uses为0，而_Weaks不为0，无论是int(10)的空间还是引用计数对象空间都不能释放，因为_Weaks不为0，引用计数对象空间不能释放，整块资源都不能释放

  • 当资源对象很大时，Uses_为0，也不能及时释放，会占用系统空间。而使用make_shared可以减少内存分配的次数，且能防止了资源泄露

  • 无法自定义删除器，默认析构函数是delete，无法管理打开的文件。如果想自定义删除器，还得手动调用构造函数

bugcoder-9905
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++智能指针shared-ptr讲解与使用.pdf
02-27
C++智能指针shared_ptr讲解与使⽤ ⼿动管理的弊端 在简单的程序中，我们不⼤可能忘记释放 new 出来的指针，但是随着程序规模的增⼤，我们忘了 delete 的概率也随之增⼤。在 C++ 中 new 出来的指针，赋值意味着引⽤的...
C++智能指针之shared_Ptr的原理以及简单实现
Arthur__Cui的博客
07-27 2129
所绑定的一种解决可能存在的资源泄露等问题的策略。能够自动管理内存的大致原理是：对象调用构造，资源就保存，对象不使用之后调用析构，则资源顺带释放。它允许多个指针同时共享同一个对象，同时确保当所有指向该对象的指针都被销毁时，该对象也会被正确地释放。​ 关于智能指针，它是一种C++对象，它的行为类似于指针，但是它具有自动管理内存的能力。智能指针常见的思想是。记录有多少个指针指向它，存在即+1，不指向则-1，归0后则释放资源。我们想要的计数器必须是同一份资源的计数器，而且是多个对象所共享的，所以。
shared_ptr的简单实现
tp_0moyi0的博客
04-25 3397
shared_ptr是c++中的一种常用智能指针，它能够解决C++程序员未及时释放内存空间导致的内存泄露问题。shared_ptr的实现核心是改变其中的引用计数值，下面是我实现的一个简单的shared_ptr，其中主要包括拷贝构造函数、赋值运算符等。 #include <iostream> using namespace std; template <typename T> class myshared_ptr { public: myshared_ptr(T*value) /
c++智能指针shared_ptr的实现
asdasd121312dasd的博客
11-20 1548
这个功能，并且得分两个类进行实现，Ref主要负责存储引用计数和原始指针，而Shared_ptr部分，将存储Ref指针，这样我们让所有共用一块堆区内存的Shared_ptr对象公用一个Ref指针，我们每析构一次Shared_ptr，就让Ref指针里面的引用计数--，这样就可以实现shared_ptr。普通赋值我们需要将原来指针的引用计数减一，然后将原来成员的Ref指针传给新成员的Ref指针，并且再次让Ref对应的引用计数加一，为什么不直接让Ref不变呢？我们想将shared_ptr实现，一定会用到。
shared_ptr代码实现
weixin_43246170的博客
11-15 2379
shared_ptr代码实现 #include <iostream> using namespace std; template <class T> class shared_ptr { private: // 保存真实指针 T* ptr_; // 指向引用计数 int* ref_count_; public: shared_ptr(T *t) { ptr_ = t; // 初始化引用计数
C++之共享智能指针shared_ptr的实现
m0_58495729的博客
10-09 3083
理解共享智能指针shared_ptr的计数器
C++智能指针详解(1).pdf
02-27
（有某个对象的所有权（访问权，⽣命控制权） 即是 强引⽤，所以shared_ptr是⼀种强引⽤型指针） （1）内部⼤概实现：每次复制，多⼀个共享同处资源的shared_ptr时，计数+1。每次释放shared_ptr时，计数-1。 当...
C++智能指针的原理和实现.pdf
02-27
简单实现： 1 template<class T> 2 class AutoPointer 3 { 4 public: 5 AutoPointer(T* ptr) 6 :mPointer(ptr){} 7 8 AutoPointer(AutoPointer<T>& other) 9 { 10 mPointer= other.mPointer; //管理权进⾏转移 11 ...
C++智能指针详解abc
08-24
weak_ptr 是一种弱引用智能指针，它可以被多个weak_ptr 对象共享，但它不会增加资源的引用计数，当所有的shared_ptr 对象都不再需要该资源时，weak_ptr 对象会自动失效。 结论 最后，需要注意的是，使用智能指针并...
strings:C ++ 1114中的字符串实现技术示例
05-14
编写它时并不是出于性能考虑（在std::shared_ptr使用std::shared_ptr进行缓冲区共享），而是为了理解该技术。 GNU stdlibc ++的std::string通常是使用这种技术构建的，但是C ++ 11引入了对迭代器无效要求的更改，...
C++智能指针shared_ptr用法
weixin_40355471的博客
12-03 8138
C++，shared_ptr对象管理指针,shared_ptr提供的接口, shared_ptr初始化,构造函数初始化,std::make_shared 初始化,reset初始化,shared_ptr管理指针的构造和析构,shared_ptr获取原始指针,shared_ptr的线程安全,shared_ptr应用之enable_shared_from_this.
为什么多线程读写 shared_ptr 要加锁？
识物专栏
04-14 663
陈硕（giantchen_AT_gmail_DOT_com）2012-01-28我在《Linux 多线程服务端编程：使用 muduo C++ 网络库》第 1.9 节“再论 shared_ptr 的线程安全”中写道：（shared_ptr）的引用计数本身是安全且无锁的，但对象的读写则不是，因为 shared_ptr 有两个数据成员，读写操作不能原子化。
C++ shared_ptr实现
weixin_44178960的博客
09-27 1173
C++ shared_ptr实现
智能指针（shared_ptr的实现）
xiaodu655的博客
01-04 9773
1.实现原理：shared_ptr是利用一个计数器，无论我们使用拷贝构造函数、赋值运算符重载、作为函数返回值、或作为参数传给一个参数时计数器+1， 当shared_ptr被赋予一个新值或者需要销毁时，计数器–，直到计数器为0时，调用析构函数，释放对象，并销毁其内存。shaerd_ptr不直接支持管理动态数组，如果希望使用shared_ptr管理一个动态数组，必须定制自己的删除器。 class Sh...
C++智能指针shared_ptr的原理与实现
weixin_44545838的博客
07-15 1177
shared_ptr 是 C++ 标准库提供的一个智能指针类，它的原理基于引用计数（reference counting）。当我们使用 shared_ptr 管理一个对象时，实际上会有一个额外的数据结构来维护引用计数信息。这个计数器会记录有多少个 shared_ptr 实例共享同一个指针对象。在创建 shared_ptr 对象时，引用计数会初始化为 1。
C++_实现一个简单的智能指针shared_ptr
惊鸿一博
01-26 1519
目录 1 shared_ptr的实现原理 2 代码简单实现 参考 1 shared_ptr的实现原理 智能指针的一种通用实现技术是使用引用计数。智能指针类将一个计数器与智能指针指向的对象相关联，用来记录有多少个智能指针指向相同的对象，并在恰当的时候释放对象。 每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，引用计数加1；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构
std::atomic 相关接口(来自cppreference.com)
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-17 968
https://en.cppreference.com/w/cpp/atomic/atomic
shared_ptr的内部实现原理
热门推荐
万里归来少年心
12-20 1万+
本文先分析shared_ptr的内部实现原理，然后实例演示shared_ptr的使用。 1. 实现原理 shared_ptr的定义如下： template<class _Ty> class shared_ptr : public _Ptr_base<_Ty> shared_ptr从基类_Ptr_base 继承了如下成员变量（部分源码）： ...
c++实现shared_ptr
最新发布
09-21
shared_ptr是C++中用于动态内存管理的智能指针之一。它能够记录对象被引用的次数，主要用于管理动态创建的对象的销毁。使用shared_ptr可以避免内存泄漏和悬挂指针等问题。 在C++中，实现shared_ptr通常需要以下几个步骤： 1. 定义一个模板类，例如SHARED_ptr，该类将作为智能指针使用。 2. 在SHARED_ptr类中，定义一个指针成员变量ptr，用于指向实际的对象。 3. 在SHARED_ptr类中，定义一个计数器类的指针成员变量refcount，用于记录对象被引用的次数。 4. 在SHARED_ptr类中，实现构造函数，用于初始化指针和计数器。 5. 在SHARED_ptr类中，实现拷贝构造函数和赋值操作符重载，用于处理多个智能指针共享同一对象的情况。 6. 在SHARED_ptr类中，实现析构函数，用于释放对象的内存空间。 7. 在SHARED_ptr类中，实现箭头运算符重载和解引用运算符重载，用于访问对象的成员函数和数据。 8. 在SHARED_ptr类外部，实现计数器类RefCount，用于记录对象被引用的次数，并在引用次数为0时释放对象的内存空间。 实现shared_ptr的详细代码如下所示： ```cpp template <class T> class SHARED_ptr { private: T* ptr; // 用来指向堆区对象 RefCount<T>* refcount; // 指向计数器对象的指针 public: SHARED_ptr(T* p) : ptr(p), refcount(new RefCount<T>()) { refcount->increment(); } SHARED_ptr(const SHARED_ptr<T>& other) : ptr(other.ptr), refcount(other.refcount) { refcount->increment(); } ~SHARED_ptr() { if (refcount->decrement() == 0) { delete ptr; delete refcount; } } T* operator->() const { return ptr; } T& operator*() const { return *ptr; } SHARED_ptr& operator=(const SHARED_ptr<T>& other) { if (this != &other) { if (refcount->decrement() == 0) { delete ptr; delete refcount; } ptr = other.ptr; refcount = other.refcount; refcount->increment(); } return *this; } }; ``` 以上是一个简单的C++实现shared_ptr的示例代码。通过使用shared_ptr，我们可以方便地管理动态创建的对象的生命周期，并避免内存泄漏和悬挂指针等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bugcoder-9905

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值