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

　　1、shared_ptr：一种计数指针，被指向的对象在引用计数为0时删除。它表示共享的所有权（负责对象的删除销毁）。需要包含<memory>，下同。

// 定义删除器
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);

　　有时候，需要在类的成员函数里面获取到“指向”当前对象的shared_ptr（然后把它传递给其他函数）。此时，只需要继承enable_shared_from_this，即可在成员函数中使用shared_from_this()获取到shared_ptr。示例：

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; 
}

　　shared_ptr对象可以在共享一个指针P（owned pointer）所有权（负责其释放）的同时保存另一个指针P'（stored pointer，不负责其释放）。通常P和P'是相同的，但通过别名构造器（aliasing constructor）可使shared_ptr拥有不同的P和P'：

struct C
{
    C() : data(new int(10)) {}
    ~C() {delete data; data = NULL;}
    int *data;
};

int main ()
{
    std::shared_ptr<C> obj(new C);
    // sp1和sp2的use_count均为3
    // shared_ptr的*运算符和get()函数操作的均是其保存的指针P'，如*sp1==10
    // 另外，注意sp1和sp2的类型是其保存的指针P'的类型！
    std::shared_ptr<int> sp1(obj, obj -> data);
    std::shared_ptr<int> sp2(sp1);

    return 0;
}

　　关于类型转换：

template <class T, class U>
shared_ptr<T> static_pointer_cast (const shared_ptr<U>& sp) noexcept;

　　static_pointer_cast即shared_ptr的static_cast：（sp非空时）返回的对象与sp共享owned pointer，且将sp的stored pointer转换为T*类型（这里需要确保static_cast<T*>(sp.get())是合法的）。如下例：

class Test {};
class Base {};
class Derived : public Base {};

int main()
{
    std::shared_ptr<Test> tsp(new Test);
    std::shared_ptr<Base> bsp0(new Base);
    std::shared_ptr<Base> bsp(tsp, bsp0.get());
    std::shared_ptr<Derived> dsp = std::static_pointer_cast<Derived>(bsp);
    // 现在tsp、bsp0、bsp和dsp的use_count分别为3、1、3、3

    return 0;
}

　　关于排序：重载的<运算符考虑的是stored pointer的地址；而owner_before()考虑的则是owned pointer的地址，它的排序结果在shared_ptr被用于关联容器（如map）的key时使用，两个shared_ptr对象仅在共享同一指针或均为空时相等。

　　2、weak_ptr：Weak shared pointer

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;
}

　　expired()：检查weak_ptr对象是否失效（为空或已经没有shared_ptr和它一起观测某个资源)。和空weak_ptr一样，失效的weak_ptr不能用于还原出shared_ptr（lock()）。expired()和use_count()==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

　　另外，weak_ptr没有重载*和->运算符，不能像普通指针一样使用（要借助lock()，参考第一个例子中的sp2）。

　　shared_ptr还有“环状引用”的问题，也需要使用weak_ptr来规避，如下例：

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;
}

　　3、unique_ptr：

　　1）在了解unique_ptr之前，先来回顾一下auto_ptr。

　　auto_ptr：Automatic Pointer（自C++11起已弃用）。

　　auto_ptr对象对它管理的指针拥有所有权，即负责其内存释放（释放时机：auto_ptr对象销毁时）。

　　和shared_ptr一样，用同一个原生指针初始化多个auto_ptr对象会导致重复释放内存的错误。

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;
}

　　2）unique_ptr：管理指针（负责其内存释放），提供有限的垃圾回收机制，相比于原生指针几乎没有额外开销（取决于使用的deleter）。

　　（1）只支持move赋值/构造，不支持拷贝赋值/构造（因为它们被定义为deleted function）：

int main ()
{
    std::unique_ptr<int> foo(new int (101));
    std::unique_ptr<int> bar;

    // bar = foo;  // 报错：use of deleted function
    bar = std::move(foo);  // 此时foo == nullptr，*bar == 101

    return 0;
}

// 拷贝构造、拷贝赋值均不被允许
unique_ptr (const unique_ptr&) = delete;
unique_ptr& operator= (const unique_ptr&) = delete;

　　参考资料：

　　http://www.cplusplus.com

不断学习中。。。