C++——智能指针 shared_ptr

一、shared_ptr介绍

二、shared_ptr的使用

#include<iostream> using namespace std; void TestSharedPtr() { shared_ptr<int> up1(new int(10)); shared_ptr<int> up2(up1); shared_ptr<int> up3; up3 = up1; } int main() { TestSharedPtr(); _CrtDumpMemoryLeaks(); return 0; }

三、shared_ptr的模拟实现

资源可以共享：浅拷贝的基础上，可以保证资源无论被多少对象共享，最终只会释放一次。

版本一：使用一个int类型内置成员变量，再进行拷贝构造的时候进行一次++ 之后赋值给新对象。

问题： 计数有问题，不同对象之间无法实现同步共享一个计数变量！

下图就是在进行up2析构之后发现up1和up2的计数变量_count是不同值。

namespace wei { template<class T> class shared_ptr { shared_ptr(T* ptr = nullptr) : _ptr(ptr) , _count(0) { if (_ptr) { _count = 1; } } ~shared_ptr() { if (_ptr && 0 == --_count) { delete _ptr; _ptr = nullptr; } } shared_ptr(shared_ptr<T>& sp) : _ptr(sp._ptr) , _count(++sp._count) {} private: T* _ptr; int _count; }; }

版本二：考虑到使用static静态成员变量可以为对象之间所共享

析构 up2之前：

析构up2之后：

问题：当另外新的对象来的时候就会产生问题，这里的up3将所有对象所共享的_count重新经历了一次初始化，也因为所有对象共享一个_count导致了问题。

我们希望每一类对象都有属于他们的_count，up1和拷贝构造出来的up2可以使用一个_count，而新声明出来的up3对象又去使用他的_count，我们不希望他们之间进行冲突。

namespace wei { template<class T> class shared_ptr { public: shared_ptr(T* ptr = nullptr) : _ptr(ptr) { if (_ptr) { _count = 1; } } ~shared_ptr() { if (_ptr && 0 == --_count) { delete _ptr; _ptr = nullptr; } } shared_ptr(shared_ptr<T>& sp) : _ptr(sp._ptr) { _count++; } private: T* _ptr; static int _count; // 静态成员变量 }; template<class T> int shared_ptr<T>::_count = 0;// 类内声明，类外定义 }

版本三：不使用静态成员变量，借助指针类型变量

参考我们不同对象在创建时都有不同的地址空间，例如up1和up2中的_ptr就使用同一份地址，而up3中的_ptr又有它自己新的地址，能不能利用类似于_ptr的一个东西来设计一个_count存储每一堆对象们的计数。

在成员变量中新加一个指针来进行计数。

private: T* _ptr; int* _pcount;

效果如下图：

namespace wei { template<class T> class shared_ptr { public: shared_ptr(T* ptr = nullptr) : _ptr(ptr) , _pcount(nullptr) { if (_ptr) { _pcount = new int(1); } } ~shared_ptr() { if (_ptr && 0 == --(*_pcount)) { delete _ptr; delete _pcount; _ptr = nullptr; _pcount = nullptr; } } shared_ptr(shared_ptr<T>& sp) : _ptr(sp._ptr) , _pcount(sp._pcount) { (*_pcount)++; } private: T* _ptr; int* _pcount; };

版本四：为了线程安全，引入锁机制，在所有计数操作时加锁，保证操作原子性，加入DFDef保证析构的重载

#include <mutex> namespace bite { template<class T> class DFDef { public: void operator()(T*& ptr) { if (ptr) { delete ptr; ptr = nullptr; } } }; template<class T, class DF = DFDef<T>> class shared_ptr { public: // RAII shared_ptr(T* ptr = nullptr) : _ptr(ptr) , _pcount(nullptr) , _pMutex(nullptr) { if (_ptr) { _pcount = new int(1); _pMutex = new mutex(); } } ~shared_ptr() { Release(); } // 具有指针类似行为 T& operator*() { return *_ptr; } T* operator->() { return _ptr; } // 解决浅拷贝：引用计数 shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr) , _pcount(sp._pcount) , _pMutex(sp._pMutex) { AddRef(); } shared_ptr<T>& operator=(const shared_ptr<T>& sp) { if (this != &sp) { // *this要和sp去共享资源 // 1. 先让*this和离开之前的资源 Release(); // 2. *this 和 sp共享资源和计数 _ptr = sp._ptr; _pcount = sp._pcount; _pMutex = sp._pMutex; AddRef(); } return *this; } T* get() { return _ptr; } private: void AddRef() { _pMutex->lock(); ++(*_pcount); _pMutex->unlock(); } void Release() { bool flag = false; _pMutex->lock(); if (_ptr && 0 == --(*_pcount)) { DF()(_ptr); delete _pcount; _pcount = nullptr; flag = true; } _pMutex->unlock(); if (flag) { delete _pMutex; _pMutex = nullptr; } } private: T* _ptr; int* _pcount; mutex* _pMutex; }; }

四、涉及自定义类型智能指针变量线程安全实例

#include <thread> #include <mutex> struct Date { int _year = 0; int _month = 0; int _day = 0; }; void SharePtrFunc(std::shared_ptr<Date>& sp, size_t n, mutex& mtx) { cout << sp.get() << endl; for (size_t i = 0; i < n; ++i) { std::shared_ptr<Date> copy(sp); // unique_lock<mutex> lk(mtx); 保证该区域元素修改原子性 copy->_year++; copy->_month++; copy->_day++; } } void TestSharedPtr3() { std::shared_ptr<Date> sp(new Date); cout << sp.get() << endl; size_t n = 10000; mutex m; thread t1(SharePtrFunc, std::ref(sp), n, std::ref(m)); ref的用法保证传递引用 thread t2(SharePtrFunc, std::ref(sp), n, std::ref(m)); t1.join(); 进行线程等待 t2.join(); cout << sp->_year << endl; cout << sp->_month << endl; cout << sp->_day << endl; } int main() { TestSharedPtr3(); _CrtDumpMemoryLeaks(); return 0; }