0

现摘录一篇不错的讲Shared_ptr的文章，要点记录如下：

• 智能指针是为了管理针对于异常、线程间等的内存，防止发生内存泄漏而存在的
• 其基于引用计数来管理内存，每新增一个指向该对象的智能指针则引用计数加一，减少一个（如超过作用域等）则减少一个。当减少到零时会自动调用相应对象的析构函数释放内存。
• 注意避免循环引用**，shared_ptr的一个最大的陷阱是循环引用，循环，循环引用会导致堆内存无法正确释放，导致内存泄漏。

1 异常安全

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

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

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

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

void func() 
{
    auto ptr = new Widget;
    // 执行一个会抛出异常的操作
    func_throw_exception();
    
    delete ptr;
}

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

void func() 
{
    auto ptr = new Widget;
    try {
        func_throw_exception();
    }
    catch(...) {
        delete ptr;
        throw; 
    }
    delete ptr;
}

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

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

2** shared_ptr**

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

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

temple<typename T>
class SharedPtr {
public:
   ... 
private:
    T *_ptr;
    int *_refCount;     //should be int*, rather than int
};

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

~SharedPtr()
{
    if (_ptr && --*_refCount == 0) {
        delete _ptr;
        delete _refCount;
    }
}

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

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

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

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

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

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

赋值运算符的重载

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

一、sp指针指向发生变化，不再指向之前的内存区域，所以赋值前原来的_refCount要自减

二、sp指针指向other.ptr，所以other的引用计数器_refCount要做++操作。

SharedPtr &operator=(SharedPtr &other)
{
    if(this==&other)
        return *this;
        
    ++*other._refCount;
    if (--*_refCount == 0) {
        delete _ptr;
        delete _refCount;
    }
        
    _ptr = other._ptr;
    _refCount = other._refCount;
    return *this;
}

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

T &operator*()
{
    if (_refCount == 0)
        return (T*)0;
        
    return *_ptr;
}

定义指针运算符->

T *operator->()
{
    if(_refCount == 0)
        return 0;
        
    return _ptr;
}

3 测试

int main(int argc, const char * argv[])
{
    SharedPtr<string> pstr(new string("abc"));
    SharedPtr<string> pstr2(pstr);
    SharedPtr<string> pstr3(new string("hao"));
    pstr3 = pstr2;
    
    return 0;
}

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

image

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

思考

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

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