浅析C++中的智能指针

《More Effective C++》条款28中这样写道：
所谓smart pointers，是“看起来、用起来、感觉起来都像内建指针，但提供更多机能”的一种对象。
智能指针是行为类似于指针的类的对象。

为什么需要智能指针呢？
首先看如下代码：

void remodel(std::string & str)
{
    std::string *ps = new std::string(str);
    ...
    str = ps;
    return;
}

聪明的你已经发现了问题，上诉代码会造成内存泄露。所以需要在return之前加入代码：
delete ps;

但是有经验的工程师都知道：凡涉及“别忘了”的解决方法，很少是最佳的。
即使你记住了全部，看看下面的变体：

void remodel(std::string & str)
{
    std::string *ps = new std::string(str);
    ...
    if(..)
        throw exception();
    str = ps;
    delete ps;
    return;
}

当异常发生时，delete不会被执行，同样会内存泄露。
是时候智能指针出场了，**aoto_ptr、shared_ptr、unique_ptr。
aoto_ptr是C++98中提供的，C++11已经将其摒弃了。**

使用智能指针
可以将new获得的地址复制给智能指针。当智能指针过期时，其析构函数将使用delete来释放内存。
无需记住稍后释放这些内存，在智能指针过期时，这些内存将自动被释放。
首先必须包含头文件
其次：

aoto_ptr<double>pd(new double);
auto_ptr<string>ps(new string);
unique_ptr<double>pdu(new double);
shared_ptr<string>pss(new string);

因此修改上面的remodel()函数，只需三步走：
1包含头文件memory;
2将指向string的指针替换为指向string的智能指针对象；
3删除delete语句

#include<memory>
void remodel(std::string & str)
{
    std::auto_ptr<std::string>ps(new std::string(str));
    ...
    if(..)
        throw exception();
    str = ps;
    //delete ps;
    return;
}

智能指针类都有一个explicit构造函数
此时，还有需要注意的地方，我们可以看一下auto_ptr如何定义的：

template<class X> class auto_ptr
{
public:
    explicit auto_ptr(X *p = 0) throw();
    ...
};

显而易见，使用了explicit关键字。
explicit关键字只能用于修饰只有一个参数的类的构造函数，它的作用是表面该构造函数是显示的，而非隐式的。可以阻止不应该允许的经过转换构造函数进行的隐式转换的发生。

因此，请看下面的代码：

shared_ptr<double>pd;
double *p_reg = new double;
pd = p_reg;//错误，不允许隐式转换
pd = shared_ptr<double>(p_reg);//正确
shared_ptr<double>pshared = p_reg;//错误，不允许隐式转换
shared_ptr<double>pshared(p_reg);//正确

智能指针很多方面都类似常规指针
ps是一个智能指针的对象，可以对他执行解除引用操作（*ps）、用它来访问结构成员（ps->puffIndex）、将它赋给指向相同类型的常规指针。

切忌把智能指针用于非堆内存

string vacation("hello world");
shared_ptr<string>pvac(&vacation);

当pvac过期时，程序将把delete运算符用于非堆内存，将导致错误。

初步探索三个智能指针的区别
请看代码：

#include <iostream>
#include <string>
#include <memory>
using namespace std;
int main()
{
    auto_ptr<string>
    films[5] = {
        auto_ptr<string> (new string("Fowl Balls")),
        auto_ptr<string> (new string("Duck Walks")),
        auto_ptr<string> (new string("Chicken Runs")),
        auto_ptr<string> (new string("Turkey Errors")),
        auto_ptr<string> (new string("Goose Eggs"))
};
    auto_ptr<string> pwin;
    pwin = films[2]; // films[2] loses ownership. 将所有权从 films[2]转让给pwin，此时films[2]不再引用该字符串从而变成空指针
    //unique_ptr<string> pwin; //编译错误
    //pwin = films[2];
    //shared_ptr<string> pwin; //没有问题！
    //pwin = films[2];
    cout << "The nominees for best avian baseballl film are\n";
    for(int i = 0; i < 5; ++i)
        cout << *films[i] << endl;
    cout << "The winner is " << *pwin << endl;
    cin.get();
    return 0;
}

当使用shared_ptr的时候，pwin和films[2]指向同一个对象，而引用计数从1增加到了2.在程序的末尾，pwin首先调用其析构函数，该析构函数将引用计数降低到1，所以不会有问题。 即
使用auto_ptr 所有权转让 运行将会有错误
使用shared_ptr 指向同一对象，引用计数增加，不会有问题
使用unique_ptr 采用所有权模型，编译就会有错误

因此我们也可以看出unique_ptr优于auto_ptr的一个原因：
unique_ptr比auto_ptr更安全
还有一个原因就是：
auto_ptr只能与new一起使用，不能与new[]一起使用（share_ptr同样）
unique_ptr可以使用new，也可以使用new[]
分析了这么多，那么归根到底，我们如何选择呢？

选择智能指针
（1）如果程序要使用多个指向同一个对象的指针，应选择shared_ptr
这样的情况包括：
有一个指针数组，并使用一些辅助指针来标示特定的元素，如最大的元素和最小的元素；
两个对象包含都指向第三个对象的指针；
STL容器包含指针。
很多STL算法都支持复制和赋值操作，这些操作可用于shared_ptr，但不能用于unique_ptr（编译器发出warning）和auto_ptr（行为不确定）。如果你的编译器没有提供shared_ptr，可使用Boost库提供的shared_ptr。
（2）如果程序不需要多个指向同一个对象的指针，则可使用unique_ptr。如果函数使用new分配内存，并返还指向该内存的指针，将其返回类型声明为unique_ptr是不错的选择。这样，所有权转让给接受返回值的unique_ptr，而该智能指针将负责调用delete。可将unique_ptr存储到STL容器在那个，只要不调用将一个unique_ptr复制或赋给另一个算法（如sort()）