boost::smart_ptr学习笔记

scoped_ptr

scoped_ptr指针对象在其析构时或者显示调用reset方法时会确保其所指向的对象（使用new表达式创建的）会被删除。scoped_ptr指针不存在shared-ownership或transfer-of-ownership的问题，它指向对象的ownership是由其scope决定的；因为scoped_ptr指针的简单，它的效率几乎了原始指针类型一样，并且也没有额外的存储消耗。

scoped_ptr不能用于C++标准库中的容器类；并不适用用数组指针。

shared_ptr

shared_ptr指针对象使用内部计数器管理其所指向的动态分配对象，并保证当最后一个指向该动态分配对象的shared_ptr指针被销毁时（计数器为0）该动态分配对象会被删除。

shared_ptr可拷贝构造、可赋值，并可被C++标准库中的容器类使用。shared_ptr不是多线程安全的！

weak_ptr

weak_ptr是一种可构造、可赋值以不增加引用计数来管理shared_ptr的指针，它可以方便的转回到shared_ptr指针，使用weak_ptr.lock函数就可以得到一个shared_ptr的指针，如果该指针已经被其它地方释放，它则返回一个空的shared_ptr，也可以使用weak_ptr.expired()来判断一个指针是否被释放。

weak_ptr可拷贝构造、可赋值，并可被C++标准库中的容器类使用。weak_ptr不仅可以解决多线程访问带来的安全问题，而且还可以解决循环引用问题，示例见后。

shared_ptr使用陷阱

1. shared_ptr多次引用同一数据

void shared_ptr_test1() {
    int* pInt = new int[100];
    
    boost::shared_ptr<int> sp1(pInt);
    printf("sp1 use_count:%d\n", sp1.use_count());
        
    // 一些其它代码之后…
    boost::shared_ptr<int> sp2(pInt);
    printf("sp2 use_count:%d\n", sp2.use_count());
}

这种情况在实际中是很容易发生的，结果也是非常致命的，它会导致两次释放同一块内存，而破坏堆；正确得做法是使用sp1去初始化sp2。

运行输出为：

sp1 use_count:1
sp2 use_count:1
*** glibc detected *** double free or corruption (!prev): 0x08ea5008 ***

2. shared_ptr循环引用导致内存泄露

  class parent;
class child; 

typedef boost::shared_ptr<parent> parent_ptr;
typedef boost::shared_ptr<child> child_ptr; 

class parent
{
public:
    ~parent() {
        cout << "~parent() is called" << endl; 
    }

public:
    child_ptr children;
};

class child
{
public:
    ~child() { 
        cout << "~child() is called" << endl;
    }

public:
    parent_ptr parent;
};


int main() {
    parent_ptr father(new parent());
    child_ptr son(new child());

    //父子互相引用
    father->children = son;
    son->parent = father;
    printf("father use_count:%d, son use_count:%d\n", father.use_count(), son.use_count());
    
    return 0;
}

运行输出为：

father use_count:2, son use_count:2

在程序退出前，father的引用计数为2，son的计数也为2；退出时，shared_ptr所作操作就是简单的将计数减1，如果为0则释放，显然这个情况下，引用计数不为0，因为father和son指向的动态分配对象还有shared_ptr指向对方对象，于是造成father和son所指向的内存得不到释放，导致内存泄露。

使用weak_ptr即可解决这个问题，只要修改children类代码修改如下，即可打破循环引用：

class child
{
public:
    ~child() { 
        cout << "~child() is called" << endl;
    }

public:
    boost::weak_ptr<parent> _parent;
};

运行输出为：

father use_count:1, son use_count:2
~parent() is called
~child() is called

3.使用shared_ptr包装this指针带来的问题

  class tester {
public:
    ~tester() {
        std::cout << "~tester() is called\n"; 
    }

    boost::shared_ptr<tester> sget() {
        return boost::shared_ptr<tester>(this);
    }
};

int main() {
    tester t;
    boost::shared_ptr<tester> sp =  t.sget();
    return 0;
}

运行输出为：

~tester() is called
~tester() is called

也导致了两次释放t对象破坏堆栈，一次是出栈时对象析构，一次就是shared_ptr析构。若有这种需要，可以使用下面方法：

      class tester : public boost::enable_shared_from_this<tester> {
public:
    ~tester() {
        std::cout << "~tester() is called\n"; 
    }

    boost::shared_ptr<tester> sget() {
        return shared_from_this();
    }
};

int main() {
    boost::shared_ptr<tester> sp(new tester);
    boost::shared_ptr<tester> sp2 = sp->sget();
    return 0;
}

4.在多线程程序中使用shared_ptr应注意的问题

class tester {
public:
    tester() {}
    ~tester() {}
};

void fun(boost::shared_ptr<tester> sp) {
    boost::shared_ptr<tester> tmp = sp;
}

int main() {
    boost::shared_ptr<tester> sp1(new tester);

    boost::thread t1(boost::bind(&fun, sp1));
    boost::thread t2(boost::bind(&fun, sp1));

    t1.join();
    t2.join();
    return 0;
}

这个代码带来的问题很显然，由于多线程同是访问智能指针，并将其赋值到其它同类智能指针时，很可能发生两个线程同时在操作引用计数（但并不一定绝对发生），而导致计数失败或无效等情况，从而导致程序崩溃，如若不知根源，就无法查找这个bug，那就只能向上帝祈祷程序能正常运行。

可能一般情况下并不会写出上面这样的代码，但是下面这种代码与上面的代码同样，如下：

class tester {
public:
    tester() {}
    ~tester() {}

    boost::shared_ptr<int> m_spData;
};

tester gObject;

void fun(void) {
    boost::shared_ptr<int> tmp = gObject.m_spData;
}

int main() {
    boost::thread t1(&fun);
    boost::thread t2(&fun);
    t1.join();
    t2.join();
    return 0;
}

情况是一样的。要解决这类问题的办法也很简单，使用boost.weak_ptr就可以很方便解决这个问题。第一种情况修改代码如下：

class tester {
public:
    ~tester() {
        std::cout << "~tester() is called\n"; 
    }
};

void fun(boost::weak_ptr<tester> wp) {
    boost::shared_ptr<tester> sp = wp.lock();

    if (sp) {
        //在这里可以安全的使用sp指针
    } else {
        std::cout << "shared_ptr is already released!" << std::endl;
    }
}

int main() {
    boost::shared_ptr<tester> sp1(new tester);
    boost::weak_ptr<tester> wp(sp1);

    boost::thread t1(boost::bind(&fun, wp));
    boost::thread t2(boost::bind(&fun, wp));
    t1.join();
    t2.join();

    return 0;
}

使用weak_ptr.lock()就可以得到一个shared_ptr的指针，如果该指针已经被其它地方释放，它则返回一个空的shared_ptr，也可以使用weak_ptr.expired()来判断一个指针是否被释放。

参考资料：

Boost.shared_ptr必须注意的一些地方