智能指针原理及实现（1）shared_ptr

0、异常安全

C++没有内存回收机制，每次程序员new出来的对象须要手动delete，流程复杂时可能会漏掉delete，致使内存泄漏。因而C++引入智能指针，可用于动态资源管理，资源即对象的管理策略。

使用 raw pointer 管理动态内存时，常常会遇到这样的问题：

• 忘记delete内存，形成内存泄露。
• 出现异常时，不会执行delete，形成内存泄露。

下面的代码解释了，当一个操做发生异常时，会致使delete不会被执行：

1 void func() 2 { 3     auto ptr = new Widget; 4     // 执行一个会抛出异常的操做
5  func_throw_exception(); 6     
7     delete ptr; 8 }

在C++98中，为了写出异常安全的代码，代码常常写的很笨拙，以下：

 1 void func()  2 {  3     auto ptr = new Widget;  4     try {  5  func_throw_exception();  6  }  7     catch(...) {  8         delete ptr;  9         throw; 10  } 11     delete ptr; 12 }

使用智能指针能轻易写出异常安全的代码，由于当对象退出做用域时，智能指针将自动调用对象的析构函数，避免内存泄露。

1、智能指针shared_ptr

智能指针主要有三种：shared_ptr，unique_ptr和weak_ptr。

 shared_ptr

shared_ptr是最经常使用的智能指针（项目中我只用过shared_ptr）。shared_ptr采用了引用计数器，多个shared_ptr中的T *ptr指向同一个内存区域（同一个对象），并共同维护同一个引用计数器。shared_ptr定义以下,记录同一个实例被引用的次数，当引用次数大于0时可用，等于0时释放内存。

注意避免循环引用，shared_ptr的一个最大的陷阱是循环引用，循环，循环引用会致使堆内存没法正确释放，致使内存泄漏。循环引用在weak_ptr中介绍。

1 temple<typename T>
2 class SharedPtr { 3 public: 4  ... 5 private: 6     T *_ptr; 7     int *_refCount;     //should be int*, rather than int
8 };

shared_ptr对象每次离开做用域时会自动调用析构函数，而析构函数并不像其余类的析构函数同样，而是在释放内存是先判断引用计数器是否为0。等于0才作delete操做，不然只对引用计数器左减一操做。

1 ~SharedPtr() 2 { 3     if (_ptr && --*_refCount == 0) { 4         delete _ptr; 5         delete _refCount; 6  } 7 }

 

接下来看一下构造函数，默认构造函数的引用计数器为0，ptr指向NULL：

1 SharedPtr() : _ptr((T *)0), _refCount(0) 2 { 3 }

用普通指针初始化智能指针时，引用计数器初始化为1：

1 SharedPtr(T *obj) : _ptr(obj), _refCount(new int(1)) 2 { 3 } //这里没法防止循环引用，若咱们用同一个普通指针去初始化两个shared_ptr，此时两个ptr均指向同一片内存区域，可是引用计数器均为1，使用时须要注意。

拷贝构造函数须要注意，用一个shared_ptr对象去初始化另外一个shared_ptr对象时，引用计数器加一，并指向同一片内存区域：

1 SharedPtr(SharedPtr &other) : _ptr(other._ptr), _refCount(&(++*other._refCount)) 2 { 3 }

 

赋值运算符的重载

当用一个shared_ptr<T> other去给另外一个 shared_ptr<T> sp赋值时，发生了两件事情：

1、sp指针指向发生变化，再也不指向以前的内存区域，因此赋值前原来的_refCount要自减

2、sp指针指向other.ptr，因此other的引用计数器_refCount要作++操做。

 1 SharedPtr &operator=(SharedPtr &other)  2 {  3     if(this==&other)  4         return *this;  5         
 6     ++*other._refCount;  7     if (--*_refCount == 0) {  8         delete _ptr;  9         delete _refCount; 10  } 11         
12     _ptr = other._ptr; 13     _refCount = other._refCount; 14     return *this; 15 }

 

定义解引用运算符，直接返回底层指针的引用：

1 T &operator*() 2 { 3     if (_refCount == 0) 4         return (T*)0; 5         
6     return *_ptr; 7 }

 

定义指针运算符->

1 T *operator->() 2 { 3     if(_refCount == 0) 4         return 0; 5         
6     return _ptr; 7 }

 

2、测试

1 int main(int argc, const char * argv[]) 2 { 3     SharedPtr<string> pstr(new string("abc")); 4     SharedPtr<string> pstr2(pstr); 5     SharedPtr<string> pstr3(new string("hao")); 6     pstr3 = pstr2; 7     
8     return 0; 9 }

为了让测试结果更明显，我在方法中加入了一些输出，测试结果以下：

 源码连接：https://github.com/guhowo/test/tree/master/cplus/SharedPtr

 

思考

一、本文这种写法不是线程安全的，是吧？

二、boost中的shared_ptr线程安全吗？