【C++】智能指针_boost 和std的智能指针-CSDN博客

本文链接：https://blog.csdn.net/flyingcloud6/article/details/129044259

2、shared_ptr（最好的智能指针）

四、C++11中新提供的智能指针

unique_ptr

shared_ptr

std::shared_ptr的循环引用问题

weak_ptr弱指针

shared_ptr 定制删除器（智能指针真强大！！！）

一、先来看一下什么是智能指针

智能： 可以看到我们在申请资源之后并没有进行手动释放但是却没有内存的泄漏

指针： 他明明是个对象，但用起来却像指针一样

可以发现，智能指针是很神奇的，下面让我们来看看他是怎样做到这些的吧

二、 auto_ptr

1、C++98版本

原理如下：类中含有两个成员

模拟：

C++98有着很大的缺陷，主要就是拥有权的问题

当拥有权转移之后，原来的还能去访问到数据，这显然是一种藕断丝连的现象

这就导致了一种错觉，仿佛转移之后还拥有着使用权

2、C++11的auto_ptr

我们来看看C++11对这种现象是怎么处理的

我们可以发现C++11就改进了这一点，不存在藕断丝连这一说了

三、boost 库中的智能指针

1. scoped_ptr

这个指针是个局部智能指针，就像个“貔貅”一样，只进不出，不允许拥有权的转移，构造拷贝都无法进行，底层是一个普通的指针

模拟实现：

template<class T>
class scoped_ptr
{
public:
	scoped_ptr(T* p = 0) : px(p)
	{
	}
	~scoped_ptr()
	{
		//检查释放
		//boost::checked_delete( px );
		delete px;
	}
public:
	T& operator*() const
	{
		return *px;
	}

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

	T* get() const
	{
		return px;
	}
public:
	typedef scoped_ptr<T> this_type;
	void reset(T* p = 0)
	{
		//构造一个无名临时对象
		this_type(p).swap(*this);

		//this_type(p)  ==> scoped_ptr<T>(p);
	}
	void swap(scoped_ptr& b) // never throws
	{
		T* tmp = b.px;
		b.px = px;
		px = tmp;
	}
private:
	scoped_ptr(scoped_ptr const&);
	scoped_ptr& operator=(scoped_ptr const&);  //私有的设置，不允许拷贝，赋值
	void operator==(scoped_ptr const&) const;
	void operator!=(scoped_ptr const&) const;
private:
	T* px;
};

2、shared_ptr（最好的智能指针）

底层原理图：内部是有一个引用计数器

引用计数器和之前学过的写实拷贝的地方实现原理很相似

功能： 允许拷贝，赋值还可以输出有几个引用

模拟实现：

实现这个shared_ptr 智能指针需要有四个类

1. class shared_ptr类


#include"shared_count.h"

namespace zyf
{
	template<class T>
	class shared_ptr
	{
		typedef shared_ptr<T> this_type;
	public:
		shared_ptr():px(0)
		{}
		template<class Y>
		shared_ptr(Y* p) : px(p), pn(p)
		{
#ifdef DISPLAY
			cout << "Created shread_ptr obj." << endl;
#endif
		}
		~shared_ptr()
		{
#ifdef DISPLAY
			cout << "Free shread_ptr obj." << endl;
#endif
		}
		shared_ptr& operator=(const shared_ptr& r)
		{
			this_type(r).swap(*this);
			return *this;
		}
		shared_ptr(const shared_ptr<T> &r):px(r.px),pn(r.pn)
		{}
	public:
		long use_count()const
		{
			return pn.use_count();
		}
	public:
		T& operator*()const
		{
			return *px;
		}
	public:
		void swap(shared_ptr<T>& other)
		{
			std::swap(px, other.px);
			pn.swap(other.pn);
		}
	private:
		T* px;
		shared_count pn;//引用计数器对象
	};
}

2. shared_count 类

//引用计数器类
class shared_count
{
public:
	shared_count():pi_(0)
	{}
	template<class Y>
	shared_count(Y *p):pi_(0)
	{
		pi_ = new sp_counted_impl<Y>(p);//多态
#ifdef DISPLAY
		cout << "Created shread_count obj." << endl;
#endif
	}
	~shared_count()
	{
#ifdef DISPLAY
		cout << "Free shread_count obj." << endl;
#endif
		if (pi_)
			pi_->release();
	}
	shared_count(const shared_count& r):pi_(r.pi_)
	{
		if (pi_ != 0)
			pi_->add_ref_copy();
	}

public:
	long use_count()const
	{
		if (pi_ == nullptr)
			return 0;
		return pi_->use_count();		
	}
public:
	void swap(shared_count& r)
	{
		sp_counted_base* tmp = r.pi_;
		r.pi_ = pi_;
		pi_ = tmp;
	}
private:
	sp_counted_base* pi_;
};

3. sp_counted_base类

class sp_counted_base
{
public:
	sp_counted_base() :use_count_(1)
	{
#ifdef DISPLAY
		cout << "Created sp_counted_base obj" << endl;
#endif
	}
	virtual ~sp_counted_base()
	{
#ifdef  DISPLAY
		cout << "Free sp_counted_base obj" << endl;
#endif
	}
public:
	void add_ref_copy()
	{
		use_count_++;
	}
	void release()
	{
		if (--use_count_ == 0)
		{
			delete this;
		}
	}
	long use_count()const
	{
		return use_count_;
	}
private:
	long use_count_;
	
};

4.sp_counted_impl类，这个类是继承 sp_sounted_base 类的

#include"sp_counted_base.h"

template<class X>
class sp_counted_impl : public sp_counted_base
{
public:
	sp_counted_impl(X *px):px_(px)
	{
#ifdef DISPLAY
		cout << "Created sp_sounted_impl obj." << endl;
#endif
	}
	~sp_counted_impl()
	{
		delete px_;
#ifdef DISPLAY
		cout << "Free sp_sounted_impl obj." << endl;
#endif
	}
private:
	X* px_;
};