C++11|C++11 智能指针的具体使用 C++11智能指针的具体使用

智能指针的原理

RAII
智能指针的原理
auto_ptr

1.auto_ptr的使用及问题

unique_ptr

shared_ptr

shared_ptr的循环引用

智能指针的原理
RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

不需要显式地释放资源。
采用这种方式，对象所需的资源在其生命期内始终保持有效。

我们使用RAII的思想设计SmartPtr类：

template class SmartPtr{public: SmartPtr(T* ptr):_ptr(ptr) {}~SmartPtr() {if (_ptr){delete _ptr; _ptr = nullptr; } }private: T* _ptr; };

智能指针的原理
上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：SmartPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。

template class SmartPtr{public: SmartPtr(T* ptr):_ptr(ptr) {} T& operator*() {return *_ptr; } T* operator->() {return _ptr; }~SmartPtr() {if (_ptr){delete _ptr; _ptr = nullptr; } }private: T* _ptr; };

智能指针使用：

文章图片

总结智能指针的原理：

RAII特性
重载operator*和opertaor->，具有像指针一样的行为。

auto_ptr

1.auto_ptr的使用及问题 auto_ptr的头文件#include
auto_ptr的使用：

文章图片

文章图片

为什么此时访问sp的成员时会报错呢？我们来看看它们的地址。

文章图片

我们发现在拷贝构造之后，sp管理的地址为空，而sp1管理的地址是之前sp所管理的地址，管理权发生了转移。那么上面所说的报错也很容易想通，因为sp管理的地址为空，不能进行访问。
auto_ptr的问题：当对象拷贝或者赋值后，管理权进行转移，造成前面的对象悬空。auto_ptr问题是非常明显的，所以实际中很多公司明确规定了不能使用auto_ptr。
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份AutoPtr来了解它的原理：

templateclass AutoPtr{public: AutoPtr(T* ptr):_ptr(ptr) {} //拷贝：管理权转移 AutoPtr(AutoPtr &sp):_ptr(sp._ptr) {sp._ptr = nullptr; } //赋值：管理权转移 AutoPtr& operator=(AutoPtr &sp) {if (this != &sp){if (_ptr)delete _ptr; _ptr = sp._ptr; sp._ptr = nullptr; }return *this; } ~AutoPtr() {if (_ptr){delete _ptr; _ptr = nullptr; } } T* operator->() {return _ptr; } T& operator*() {return *_ptr; }private: T* _ptr; };

unique_ptr
为了解决拷贝或者赋值时管理权转移的问题，出现了unique_ptr。
unique_ptr解决问题的方式非常粗暴：防拷贝，也就是不让赋值和拷贝
unique_ptr的使用：

文章图片

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理：

templateclass UniquePtr{public: UniquePtr(T* ptr):_ptr(ptr) {} // C++11防拷贝的方式：delete UniquePtr(const UniquePtr &) = delete; UniquePtr& operator=(const UniquePtr&) = delete; T* operator->() {return _ptr; } T& operator*() {return *_ptr; } ~UniquePtr() {if (_ptr){delete _ptr; _ptr = nullptr; } }private: //C++98防拷贝的方式：只声明不实现+声明成私有 //UniquePtr(UniquePtr const &); //UniquePtr& operator=(UniquePtr const &); T* _ptr; };

shared_ptr
c++11中提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr的使用

文章图片

shared_ptr中拷贝与赋值都是没有问题的。
shared_ptr的原理

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

shared_ptr中成员函数：use_count（对象数据的引用计数）

示例：

文章图片

示例详解：

文章图片

利用引用计数简单的实现SharedPtr，了解原理：

templateclass SharedPtr{public: SharedPtr(T* ptr):_ptr(ptr),_count(new int(1)) {} SharedPtr(const SharedPtr &sp):_ptr(sp._ptr),_count(sp._count) {//计数器累加++(*_count); } SharedPtr& operator=(const SharedPtr &sp) {//判断管理的是否是同一份资源if (_ptr != sp._ptr){//计数-1，判断之前管理的资源是否需要释放if ((--(*_count)) == 0){delete _ptr; delete _count; }_ptr = sp._ptr; _count = sp._count; //计数器累加++(*_count); }return *this; } T* operator->() {return _ptr; } T& operator*() {return *_ptr; } ~SharedPtr() {if (--(*_count) == 0){delete _ptr; delete _count; _ptr = nullptr; _count = nullptr; } }private: T* _ptr; int* _count; //给每份资源开辟一个计数器};

但是还存在一个线程安全的问题：

智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2。这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、- -是需要加锁的，也就是说引用计数的操作是线程安全的。
智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

这里我们通过加锁来解决线程安全问题：

templateclass SharedPtr{public: SharedPtr(T* ptr):_ptr(ptr),_count(new int(1)),_mutex(new mutex) {} SharedPtr(const SharedPtr &sp):_ptr(sp._ptr),_count(sp._count),_mutex(sp._mutex) {//计数器累加AddCount(); } SharedPtr& operator=(const SharedPtr &sp) {//判断管理的是否是同一份资源if (_ptr != sp._ptr){//计数-1，判断之前管理的资源是否需要释放if (SubCount() == 0){delete _ptr; delete _count; delete _mutex; }_ptr = sp._ptr; _count = sp._count; _mutex = sp._mutex; //计数器累加AddCount(); }return *this; } //线程安全的累加器 int AddCount() {//加锁_mutex->lock(); ++(*_count); _mutex->unlock(); return *_count; } int SubCount() {_mutex->lock(); --(*_count); _mutex->unlock(); return *_count; } T* operator->() {return _ptr; } T& operator*() {return *_ptr; } ~SharedPtr() {if (SubCount() == 0){delete _ptr; delete _count; delete _mutex; _ptr = nullptr; _count = nullptr; _mutex = nullptr; } } private: T* _ptr; int* _count; //给每份资源开辟一个计数器 mutex* _mutex; //每一份资源有一个独立的锁};

shared_ptr的循环引用
循环引用的场景：

struct ListNode{ int _data; shared_ptr _prev; shared_ptr _next; ~ListNode() { cout << "~ListNode()" << endl; }}; void test(){ shared_ptr node1(new ListNode); shared_ptr node2(new ListNode); node1->_next = node2; node2->_prev = node1; }

文章图片

node1和node2两个智能指针对象指向两个节点，两个节点的引用计数都是1。node1->next指向node2，node2->prev指向node1，两个节点的引用计数都变成2。程序运行完之后，析构node1和node2，node1和node2所指向的节点引用计数分别减1，但是node1->next指向下面节点，node2->prev指向上面节点，此时，两个节点的引用计数都为1，所以两个节点不能析构。
引用计数为0时，如果要析构node1节点，就先要去析构node1中的自定义结构，然后再析构node1。也就是说node1->next析构了，node2就释放了；node2->prev析构了，node1就释放了。但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。
解决方案：
在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
原理就是，node1->_next = node2和node2->_prev = node1时weak_ptr的_next和_prev不会增加node1和node2的引用计数。
weak_ptr最大作用就是解决shared_ptr的循环引用

struct ListNode{ int _data; weak_ptr _prev; weak_ptr _next; ~ListNode() { cout << "~ListNode()" << endl; }}; void test(){ shared_ptr node1(new ListNode); shared_ptr node2(new ListNode); node1->_next = node2; node2->_prev = node1; }

注意：
weak_ptr不能单独使用，可以用shared_ptr创建