标签:智能指针 shared_ptr 循环引用 定置删除器 auto_ptr scoped_ptr
auto_ptr与scoped_ptr的实现见本人的上篇博客。
三、shared_ptr
shared_ptr的实现原理是通过引用计数来实现,只有当引用计数为1时才释放空间,否则只需将引用计数减1.拷贝和赋值将引用计数加1,具体代码如下:
template <typename T> class SharedPtr { public: SharedPtr(); SharedPtr(T* ptr); SharedPtr(const SharedPtr<T>& ap); ~SharedPtr(); //SharedPtr<T>& operator=(const SharedPtr<T>& ptr);//传统写法 SharedPtr<T>& operator=(SharedPtr<T> ap);//现代写法 T& operator*()const; T* operator->()const; long GetCount()const; T* GetPtr()const; protected: void _Realease(); protected: T* _ptr; long* _pCount; }; template <typename T> SharedPtr<T>::SharedPtr() :_ptr(NULL), _pCount(new long(1)) {} template <typename T> SharedPtr<T>::SharedPtr(T* ptr) : _ptr(ptr), _pCount(new long(1)) {} template <typename T> SharedPtr<T>::SharedPtr(const SharedPtr<T>& ap) : _ptr(ap._ptr), _pCount(ap._pCount) { ++(*this->_pCount); } template <typename T> SharedPtr<T>::~SharedPtr() { this->_Realease(); } //template <typename T>//传统写法 //SharedPtr<T>& SharedPtr<T>::operator=(const SharedPtr<T>& ap) //{ // if (this->_ptr != ap._ptr) // { // this->_Realease(); // this->_ptr = ap._ptr; // this->_pCount = ap._pCount; // ++(*this->_pCount); // } // return *this; //} template <typename T>//现代写法 SharedPtr<T>& SharedPtr<T>::operator=(SharedPtr<T> ap) { swap(this->_ptr, ap._ptr); swap(this->_pCount, ap._pCount); return *this; } template <typename T> T& SharedPtr<T>::operator*()const { return *(this->_ptr); } template <typename T> T* SharedPtr<T>::operator->()const { return this->_ptr; } template <typename T> long SharedPtr<T>::GetCount()const { return *(this->_pCount); } template <typename T> T* SharedPtr<T>::GetPtr()const { return this->_ptr; } template <typename T> void SharedPtr<T>::_Realease() { if (--(*this->_pCount) == 0) { delete this->_ptr; delete this->_pCount; } }
然而上面用引用计数实现的简化版看起来不错,但却存在以下问题:
1、引用计数更新存在着线程安全
2、循环引用
3、定置删除器,比如要关闭一个文件,用malloc开辟出来的空间,上述代码均会出现问题
问题1的解决需要对改变引用计数时加锁。我们暂时不讨论,一下我们主要看第二个和第三个问题。
循环引用:
比如有以下结构体和主函数:
struct ListNode { shared_ptr<ListNode> _prev; //shared_ptr为库文件中实现的,只需包memory即可使用 shared_ptr<ListNode> _next; ~ListNode() { cout << "~ListNode()" << endl; } }; int main() { shared_ptr<ListNode> prev; //语句1 shared_ptr<ListNode> next; //语句2 prev->_next = next; //语句3 next->_prev = prev; //语句4 }
经语句1、2之后prev的引用计数为1,经3、4后为2,但是最后两个对象均不能释放,因为prev的要释放的前提是next释放,而next的释放又依赖于prev的释放。最后就形成了循环引用,谁都是放不了。解决方案如下:
struct ListNode { weak_ptr<ListNode> _prev; weak_ptr<ListNode> _next; ~ListNode() { cout << "~ListNode()" << endl; } };
因为weak_ptr(弱引用智能指针)会对引用计数会做特殊处理(上述情况不加1)。
定置删除器和空间分配器(ps:空间分配器的定置特殊场景下才会这样使用)
eg:如果指针是一个指向文件类型的,在析构函数中只需关闭文件即可,而不是释放空间;如果空间是通过,malloc出来的,那么在析构函数中要调用free函数,而不是delete操作符。上述问题通过仿函数就可以解决。具体代码如下:
template <typename T,class Deleter = Del<T>> class SharedPtr { public: SharedPtr(T* ptr); SharedPtr(T* ptr, Deleter del); SharedPtr(const SharedPtr<T, Deleter>& ap); ~SharedPtr(); //SharedPtr<T, Deleter>& operator=(const SharedPtr<T, Deleter>& ptr);//传统写法 //现代写法 SharedPtr<T, Deleter>& operator=(SharedPtr<T, Deleter> ap); T& operator*()const; T* operator->()const; long GetCount()const; T* GetPtr()const; protected: void _Realease(); protected: T* _ptr; long* _pCount; Deleter _del; }; template <typename T, class Deleter = Del<T>> SharedPtr<T, Deleter>::SharedPtr(T* ptr) :_ptr(ptr), _pCount(new long(1)) {} template <typename T, class Deleter = Del<T>> SharedPtr<T, Deleter>::SharedPtr(T* ptr, Deleter del) : _ptr(ptr), _pCount(new long(1)), _del(del) {} template <typename T, class Deleter = Del<T>> SharedPtr<T, Deleter>::SharedPtr(const SharedPtr<T, Deleter>& ap) : _ptr(ap._ptr), _pCount(ap._pCount), _del(ap._del) { ++(*this->_pCount); } template <typename T, class Deleter = Del<T>> SharedPtr<T, Deleter>::~SharedPtr() { this->_Realease(); } //template <typename T, class Deleter = Del<T>>//传统写法 //SharedPtr<T, Deleter>& SharedPtr<T, Deleter>::operator=(SharedPtr<T, Deleter> ap) //{ // if (this->_ptr != ap._ptr) // { // this->_Realease(); // this->_ptr = ap._ptr; // this->_pCount = ap._pCount; // ++(*this->_pCount); // } // return *this; //} template <typename T, class Deleter = Del<T>>//现代写法 SharedPtr<T, Deleter>& SharedPtr<T, Deleter>::operator=(SharedPtr<T, Deleter> ap) { swap(this->_ptr, ap._ptr); swap(this->_pCount, ap._pCount); swap(this->_del, ap._del); return *this; } template <typename T, class Deleter = Del<T>> T& SharedPtr<T, Deleter>::operator*()const { return *(this->_ptr); } template <typename T, class Deleter = Del<T>> T* SharedPtr<T, Deleter>::operator->()const { return this->_ptr; } template <typename T, class Deleter = Del<T>> long SharedPtr<T, Deleter>::GetCount()const { return *(this->_pCount); } template <typename T, class Deleter = Del<T>> T* SharedPtr<T, Deleter>::GetPtr()const { return this->_ptr; } template <typename T, class Deleter = Del<T>> void SharedPtr<T, Deleter>::_Realease() { if (--(*this->_pCount) == 0) { _del(_ptr); delete this->_pCount; } }
智能指针的模拟实现shared_ptr 循环引用 定置删除器
标签:智能指针 shared_ptr 循环引用 定置删除器 auto_ptr scoped_ptr
原文地址:http://10740026.blog.51cto.com/10730026/1754477