智能指针

1. 什么是智能指针？

智能指针是行为类似于指针的类对象，但这种对象还有其他功能。

2. 为什么设计智能指针？

引例：

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

当出现异常时（weird_thing() 返回 true），delete 将不被执行，因此将导致内存泄露。

如何避免这种问题？有人会说，这还不简单，直接在 throw exception(); 之前加上 delete ps; 不就行了。是的，你本应如此，问题是很多人都会忘记在适当的地方加上 delete 语句（连上述代码中最后的那句 delete 语句也会有很多人忘记吧），如果你要对一个庞大的工程进行 review，看是否有这种潜在的内存泄露问题，那就是一场灾难！

这时我们会想：当 remodel 这样的函数终止（不管是正常终止，还是由于出现了异常而终止），本地变量都将自动从栈内存中删除——因此指针 ps 占据的内存将被释放，如果 ps 指向的内存也被自动释放，那该有多好啊。我们知道析构函数有这个功能。如果 ps 有一个析构函数，该析构函数将在 ps 过期时自动释放它指向的内存。但 ps 的问题在于，它只是一个常规指针，不是有析构函数的类对象指针。如果它指向的是对象，则可以在对象过期时，让它的析构函数删除指向的内存。

这正是 auto_ptr、unique_ptr 和 shared_ptr 这几个智能指针背后的设计思想。简单的总结下就是：将基本类型指针封装为类对象指针（这个类肯定是个模板，以适应不同基本类型的需求），并在析构函数里编写 delete 语句删除指针指向的内存空间，使得指针过期时自动销毁，解决内存泄漏问题。

注意：模板 auto_ptr 是 C++98 提供的解决方案，C++11 已将其摒弃，并提供另外两种解决方案：unique_ptr 和 shared_ptr 。

3. 怎么使用智能指针？

要转换 remodel() 函数，应按下面 3 个步骤进行：

• 包含头文件 memory （智能指针所在的头文件）；
• 将指向 string 的指针替换为指向 string 的智能指针对象；
• 删除 delete 语句。

下面是使用 auto_ptr 修改该函数的结果：

# include 
void remodel (std::string & str)
{
    std::auto_ptr ps (new std::string(str))；
    ...
    if (weird_thing ())
        throw exception()； 
    str = *ps； 
    // delete ps； NO LONGER NEEDED
    return;
}

4. 都有哪些智能指针？

实际上，一共有 4 种：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr（本文暂不讨论）。

5. 有哪些注意事项？

• 所有的智能指针类都有一个 explicit 构造函数，该构造函数以指针作为参数。比如 auto_ptr 的类模板原型为：

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

  因此不需要自动将指针转换为智能指针对象：

  shared_ptr pd; 
  double *p_reg = new double;
  pd = p_reg;                               // not allowed (implicit conversion)
  pd = shared_ptr(p_reg);           // allowed (explicit conversion)
  shared_ptr pshared = p_reg;       // not allowed (implicit conversion)
  shared_ptr pshared(p_reg);        // allowed (explicit conversion)
  

• 对全部三种智能指针都应避免的一点：

  string vacation("I wandered lonely as a cloud.");
  shared_ptr pvac(&vacation);   // No!
  

  pvac 过期时，程序将把 delete 运算符用于非堆内存，这是错误的。

6. 为何摒弃 auto_ptr ？

先来看下面的赋值语句：

auto_ptr< string> ps (new string ("I reigned lonely as a cloud.”）;
auto_ptr vocation; 
vocaticn = ps;

上述赋值语句将完成什么工作呢？如果 ps 和 vocation 是常规指针，则两个指针将指向同一个 string 对象。这是不能接受的，因为程序将试图删除同一个对象两次——一次是 ps 过期时，另一次是 vocation 过期时。要避免这种问题，方法有多种：

• 定义赋值运算符，使之执行深复制。这样两个指针将指向不同的对象，其中的一个对象是另一个对象的副本，缺点不仅是浪费空间，而且失去了应用指针的初衷，所以智能指针都未采用此方案。
• 建立所有权（ownership）概念。对于特定的对象，只能有一个智能指针可拥有它，这样只有拥有对象的智能指针的析构函数会删除该对象。然后让赋值操作转让所有权。这就是用于 auto_ptr 和 unique_ptr 的策略，但 unique_ptr 的策略更严格。
• 创建智能更高的指针，跟踪引用特定对象的智能指针数。这称为引用计数（reference counting）。例如，赋值时，计数将加 1 ，而指针过期时，计数将减 1 。仅当最后一个指针过期（计数减为 0） 时，才调用 delete 。这是 shared_ptr 采用的策略。

当然，同样的策略也适用于复制构造函数。

每种方法都有其用途，但为何说要摒弃 auto_ptr 呢？下面是一个不适合使用 auto_ptr 的示例：

#include 
#include 
#include 
using namespace std;

int main() {
    auto_ptr films[5] =
    {
        auto_ptr (new string("Fowl Balls")),
        auto_ptr (new string("Duck Walks")),
        auto_ptr (new string("Chicken Runs")),
        auto_ptr (new string("Turkey Errors")),
        auto_ptr (new string("Goose Eggs"))
    };
    auto_ptr pwin;
    pwin = films[2];  // films[2] loses ownership  将所有权从 films[2] 转让给 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;
}

运行后会发现程序会崩溃。书上说错误地使用 auto_ptr 可能会导致问题（这种代码的行为是不确定的，其行为可能随系统而异）。

这里的问题在于，pwin = films[2]; 将所有权从 films[2] 转让给了 pwin 。这导致 films[2] 不再引用该字符串。在 auto_ptr 放弃对象的所有权后，便可能使用它来访问该对象。当程序打印 films[2] 指向的字符串时，却发现这是一个空指针，这显然是个讨厌的意外。

如果使用 shared_ptr 代替 auto_ptr （这要求编译器支持 C++ 新增的 shared_ptr 类），则程序将正常运行。如果使用 unique_ptr ，结果又会如何呢？与 suto_ptr 一样，unique_ptr 也采用所有权模型。但使用 unique_ptr 时，程序不会等到运行阶段崩溃，而是在编译阶段报错。

这就是为何要摒弃 auto_ptr 的原因，一句话总结就是：避免潜在的内存崩溃问题。

7. unique_ptr 为何优于 auto_ptr ？

可能大家认为前面的例子已经说明了 unique_ptr 为何优于 auto_ptr ，也就是安全问题，下面再叙述的清晰一点。

请看下面的语句：

auto_ptr p1(new string ("auto") ； //#1
auto_ptr p2;                       //#2
p2 = p1;                                   //#3

在语句 #3 中，p2 接管 string 对象的所有权后，p1 的所有权将被剥夺。前面说过，这是好事，可防止 p1 和 p2 的析构函数试图刪除同—个对象；但如果程序随后试图使用 p1，这将是件坏事，因为 p1 不再指向有效的数据。

下面来看使用 unique_ptr 的情况：

unique_ptr p3 (new string ("auto");   //#4
unique_ptr p4；                       //#5
p4 = p3;                                      //#6

编译器认为语句 #6 非法，避免了 p3 不再指向有效数据的问题。因此，unique_ptr 比 auto_ptr 更安全（编译阶段错误比潜在的程序崩溃更安全）。

有时候，会将一个智能指针赋给另一个并不会留下危险的悬挂指针。假设有如下函数定义：

unique_ptr demo(const char * s)
{
    unique_ptr temp (new string (s))； 
    return temp；
}

并假设编写了如下代码：

unique_ptr ps;
ps = demo('Uniquely special")；

demo() 返回一个临时 unique_ptr ，然后 ps 接管了原本归返回的 unique_ptr 所有的对象，而返回时临时的 unique_ptr 被销毁，也就是说没有机会使用 unique_ptr 来访问无效的数据，换句话来说，这种赋值是不会出现任何问题的，即没有理由禁止这种赋值。实际上，编译器确实允许这种赋值，这正是 unique_ptr 更聪明的地方。

总之，当程序试图将一个 unique_ptr 赋值给另一个时，如果源 unique_ptr 是个临时右值，编译器允许这么做；如果源 unique_ptr 将存在一段时间，编译器将禁止这么做：

unique_ptr pu1(new string ("hello world"));
unique_ptr pu2;
pu2 = pu1;                                      // #1 not allowed
unique_ptr pu3;
pu3 = unique_ptr(new string ("You"));   // #2 allowed

其中 #1 留下悬挂的 unique_ptr(pu1)，这可能导致危害。而 #2 不会留下悬挂的 unique_ptr，因为它调用 unique_ptr 的构造函数，该构造函数创建的临时对象在其所有权让给 pu3 后就会被销毁。这种随情况而异的行为表明，unique_ptr 优于允许两种赋值的 auto_ptr 。

这也是禁止（只是一种建议，编译器并不禁止）在容器对象中使用 auto_ptr ，但允许使用 unique_ptr 的原因。如果容器算法试图对包含 unique_ptr 的容器执行类似于语句 #1 的操作，将导致编译错误；如果算法试图执行类似于语句 #2 的操作，则不会有任何问题。而对于 auto_ptr ，类似于语句 #1 的操作可能导致不确定的行为和神秘的崩溃。

当然，您可能确实想执行类似于语句 #1 的操作，仅当以非智能的方式使用摒弃的智能指针时（如解除引用时），这种赋值才不安全。要安全地重用这种指针，可给它赋新值。C++ 有一个标准库函数 std::move() ，让你能够将一个 unique_ptr 赋给另一个。下面是一个使用前述 demo() 函数的例子，该函数返回一个 unique_ptr 对象：

unique_ptr ps1, ps2;
ps1 = demo("hello");
ps2 = move(ps1);
ps1 = demo("alexia");
cout << *ps2 << *ps1 << endl;

使用 move 后，原来的指针仍转让所有权变成空指针，可以对其重新赋值。

到这里，你可能会问：unique_ptr 如何能够区分安全和不安全的用法呢？答案是它使用了 C++11 新增的移动构造函数和右值引用。详情本文不讨论。

相比于 auto_ptr ，unique_ptr 还有另一个优点。它有一个可用于数组的变体。模板 auto_ptr 使用 delete 而不是 delete[] ，因此只能与 new 一起使用，而不能与 new[] 一起使用。但 unique_ptr 有使用 new[] 和 delete[] 的版本。

警告：使用 new 分配内存时，才能使用 auto_ptr 和 shared_ptr ，使用 new[] 分配内存时，不能使用它们。不使用 new 分配内存时，不能使用 auto_ptr 或 shared_ptr ；不使用 new 或 new[] 分配内存时，不能使用 unique_ptr 。

8. 如何选择智能指针？

在掌握了这几种智能指针后，大家可能会想另一个问题：在实际应用中，该如何选择使用哪种智能指针呢？

（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() ）。例如，可在程序中使用类似于下面的代码段，这里假设程序包含正确的 include 和 using 语句：

unique_ptr make_int(int n)
{
    return unique_ptr(new int(n));
}
void show(unique_ptr &p1)              // pass by reference
{
    cout << *a << ' ';
}
int main()
{
    ...
    vector > vp(size);
    for(int i = 0; i < vp.size(); i++)
        vp[i] = make_int(rand() % 1000);       // copy temporary unique_ptr
    vp.push_back(make_int(rand() % 1000));     // ok because arg is temporary
    for_each(vp.begin(), vp.end(), show);      // use for_each()
    ...
}

其中 push_back() 调用没有问题，因为它返回一个临时 unique_ptr，该 unique_ptr 被赋给 vp 中的一个 unique_ptr 。另外，如果按值而不是按引用给 show() 传递对象，for_each() 语句将非法，因为这将导致使用一个来自 vp 的非临时 unique_ptr 初始化 pi，而这是不允许的。前面说过，编译器将发现错误使用 unique_ptr 的企图。

在 unique_ptr 为右值时，可将其赋给 shared_ptr ，这与将一个 unique_ptr 赋给另一个需要满足的条件相同。与前面一样，在下面的代码中，make_int() 的返回类型为 unique_ptr ：

unique_ptr pup(make_int(rand() % 1000));   // ok
shared_ptr spp(pup);                       // not allowed, pup as lvalue
shared_ptr spr(make_int(rand() % 1000));   // ok

模板 shared_ptr 包含一个显式构造函数，可用于将右值 unique_ptr 转换为 shared_ptr 。shared_ptr 将接管原来归 unique_ptr 所有的对象。

在满足 unique_ptr 要求的条件时，也可使用 auto_ptr，但 unique_ptr 是更好的选择。如果你的编译器没有 unique_ptr ，可考虑使用 Boost 库提供的 scoped_ptr ，它与 unique_ptr 类似。

参考资料：

《C++ Primer Plus》第 6 版中文版
C++智能指针简单剖析