C++11新特性之智能指针

// 定义删除器
struct Deleter
{
public:
    void operator() (Base *p)
    {
        cout << "[deleter called]" << endl;
        delete p;
    }
};

int main()
{
    shared_ptr<Base> p1(new Base, Deleter());
    {
        shared_ptr<Base> p2(p1);    // 这里p1/p2的use_count()为2
        {
            shared_ptr<Base> p3(p2);    // 这里p1/p2/p3的use_count()为3
        }    // p1/p2的use_count()变为2
    }    // p1的use_count()变为1

    p1.reset();    // 无参的reset()将使p1变为空（就像默认构造时一样）

    // p1的use_count()变为0且上面的new Base被删除/析构

    return 0;
}

// 错误1：既使用shared_ptr，又自己管理原生指针。原生指针被重复析构
int *p = new int(9);
shared_ptr<int> sp1(p);
delete p;

// 错误2：多个shared_ptr均从同一个原生指针构造。原生指针被重复析构
// 多个shared_ptr管理同一个原生指针，则后续的shared_ptr都应直接或间接（通过weak_ptr）从第一个构造
int *q = new int(10);
shared_ptr<int> sp2(q);
shared_ptr<int> sp3(q);

class Foo;

class Bar
{
public:
    void test(shared_ptr<Foo> sp);
};

class Foo : public enable_shared_from_this<Foo>
{
public:
    void test();
    void print();
};

void Bar::test(shared_ptr<Foo> sp)
{
    // 此时sp.use_count()为3
    sp -> print();
}

void Foo::test()
{
    // 若换成shared_ptr<Foo> sp = shared_ptr<Foo>(this);会出错
    // 这相当于使用一个原生指针分别构造两个shared_ptr，会造成重复释放的问题
    shared_ptr<Foo> sp = shared_from_this();  // 此时sp.use_count()为2
    Bar bar;
    bar.test(sp);
    // 此时sp.use_count()为2
}

void Foo::print() { cout << "in Foo::print" << endl; }

int main()
{
    shared_ptr<Foo> sp1(new Foo);
    sp1 -> test();
    // 此时sp1.use_count()为1

    // !!!错误用法，抛出bad_weak_ptr异常!!!
    // 原因（参考boost的enable_shared_from_this.hpp）：enable_shared_from_this有一个weak_ptr类型的成员，
    // 它只能由shared_ptr通过enable_shared_from_this的一个成员函数赋值（故使用以下方式时，该成员为空），
    // shared_from_this()正是通过该成员“获取”到shared_ptr
    Foo *fp = new Foo;
    fp -> test();
    delete fp; 
}

int main()
{
    shared_ptr<int> sp1(new int(10));

    // 可以用shared_ptr/weak_ptr构造weak_ptr
    // weak_ptr拥有资源的访问权，但没有所有权（不会增加引用计数）
    weak_ptr<int> wp(sp1);  // wp和sp1的use_count()均为1

    if (!wp.expired())
    {
        // lock()：从weak_ptr“获取”一个可用的shared_ptr对象
        shared_ptr<int> sp2 = wp.lock();  // wp和sp1的use_count()均为2
        *sp2 = 100;
    }

    // 此时wp和sp1的use_count()均为1

    return 0;
}

weak_ptr<int> wp;    // 此时wp.expired()为1

shared_ptr<int> sp1(new int);
wp = sp1;
shared_ptr<int> sp2 = wp.lock();

// 此时wp.expired()为0

sp2.reset();    // 此时wp.expired()为0
sp1.reset();    // 此时wp.expired()为1

class parent;
class children;
typedef shared_ptr<parent> parent_ptr;  // 改为typedef weak_ptr<parent> parent_ptr;方可避免“环状引用”的问题
typedef shared_ptr<children> children_ptr;  // 改为typedef weak_ptr<children> children_ptr;方可避免“环状引用”的问题

class parent
{
public:
    children_ptr children;
};

class children
{
public:
    parent_ptr parent;
};

int main()
{
    shared_ptr<parent> father(new parent);
    shared_ptr<children> son(new children);
    father -> children = son;
    son -> parent = father;  // father和son的use_count()均为2，程序退出时没有调用parent和children的析构函数!!!

    return 0;
}

class Base
{
public:
    Base() {cout << "in Base" << endl;}
    ~Base() {cout << "in ~Base" << endl;}
    void test() {cout << "in test" << endl;}
};

int main()
{
    auto_ptr<int> ap1(new int);
    // 基本操作
    *ap1 = 10;
    int *p = ap1.get();  // *p == 10
    auto_ptr<Base> ap2(new Base);
    ap2 -> test();

    auto_ptr<Base> ap3 = ap2; // 赋值或“复制”构造时会转移所有权（故不能用于STL容器中）：ap2.get()变成NULL
    ap3 -> test();

    auto_ptr<Base> ap4(new Base);
    Base *bp = ap4.release();  // ap4.get()变成NULL。释放所有权，不再对之前管理的指针（的内存）负责。返回之前管理的指针
    delete bp;

    auto_ptr<Base> ap5(new Base);
    ap5.reset(); // “显式”销毁/析构其指向的对象。可设置指向新的对象

    return 0;
}