2024年网安最新C++进阶之路---何为智能指针？(1)-CSDN博客

本文链接：https://blog.csdn.net/2401_84969722/article/details/138733213

三、智能指针的分类

1.std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。

下面演示的auto_ptr的使用及问题。其原理是：管理权转移。

namespace GoodQ
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			// 管理权转移
			sp._ptr = nullptr;
		}
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			// 检测是否为自己给自己赋值
			if (this != &ap)
			{
				// 释放当前对象中资源
				if (_ptr)
					delete _ptr;
				// 转移ap中资源到当前对象中
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
		}
		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}
int main()
{
	 std::auto_ptr<int> sp1(new int);
	 std::auto_ptr<int> sp2(sp1); // 管理权转移

	 // sp1悬空
	 *sp2 = 10;
	 cout << *sp2 << endl;
	 cout << *sp1 << endl;
	 return 0;
}

结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr

2.std::unique_ptr

C++11中开始提供更靠谱的unique_ptr.其原理是：防止拷贝。

namespace GoodQ
{
	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;
	};
}
int main()
{
	 std::unique_ptr<int> sp1(new int);
	 return 0;
}

3.std::shard_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr。

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

1.shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
2.在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减1。
3.如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4.如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

template<class T>
class shared_ptr
{
public:
	shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		, _pcount(new int(1))
	{}
	template<class D>
	shared_ptr(T* ptr, D del)
		: _ptr(ptr)
		, _pcount(new int(1))
		, _del(del)
	{}
	void release()
	{
		if (--(*_pcount) == 0)
		{
			_del(_ptr);

			delete _pcount;
		}
	}
	~shared_ptr()
	{
		release();
	}
	shared_ptr(const shared_ptr<T>& sp)
		:_ptr(sp._ptr)
		, _pcount(sp._pcount)
	{
		++(*_pcount);
	}
	// sp1 = sp3
	shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		if (_ptr != sp._ptr)
		{
			release();

			_ptr = sp._ptr;
			_pcount = sp._pcount;

			++(*_pcount);
		}
		return *this;
	}
	// 像指针一样
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	int use_count() const
	{
		return *_pcount;
	}
	T* get() const
	{
		return _ptr;
	}
private:
	T* _ptr;
	int* _pcount;
	function<void(T*)> _del = [](T* ptr) {delete ptr; };
};

std::shared_ptr的循环引用问题

struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

循环引用分析：

1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动
delete。
       2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
       3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
       4. 也就是说_next析构了，node2就释放了。
       5. 也就是说_prev析构了，node1就释放了。
       6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。