智能指针

超、凢脫俗 2022-08-09 16:37 349阅读 0赞

**scoped\_ptr解析**

**《超越C++标准库-Boost库导论》**

**头文件: "boost/scoped\_ptr.hpp"**

boost::scoped\_ptr 用于确保动态分配的对象能够被正确地删除。scoped\_ptr有着与std::auto\_ptr类似的特性，而最大的区别在于它不能转让所有权，然而auto\_ptr却可以。事实上，scoped\_ptr永远不能被复制或被赋值！scoped\_ptr拥有它所指向的资源的所有权，并永远不会放弃这个所有权。scoped\_ptr的这种特性改进了代码的表示方式，我们可以根据需要选择最合适的智能指针(scoped\_ptr或auto\_ptr)。

要决定使用std::auto\_ptr还是boost::scoped\_ptr, 就要考虑转移所有权是不是你想要的智能指针的一个特性。如果不是，就用scoped\_ptr. 它是一种轻量级的智能指针；使用它不会使你的程序变大或变慢。它只会让你的代码更安全，更好维护。

下面是scoped\_ptr的摘要，以及其成员的简要描述：

namespace boost \{  
  template<typename T> class scoped\_ptr : noncopyable \{  
  public:  
    **explicit** scoped\_ptr(T\* p = 0);   
    ~scoped\_ptr();   
  
    void reset(T\* p = 0);   
  
    T& operator\*() const;   
    T\* operator->() const;   
    T\* get() const;   
     
    void swap(scoped\_ptr& b);   
  \};  
  
  template<typename T>   
    void swap(scoped\_ptr<T> & a, scoped\_ptr<T> & b);   
\}

**成员函数**

explicit scoped\_ptr(T\* p=0)

构造函数，存储p的一份拷贝。注意，p 必须是用operator new分配的，或者是null.在构造的时候，不要求T必须是一个完整的类型。当指针p是调用某个分配函数的结果而不是直接调用new得到的时候很有用：因为这个类型不必是完整的，只需要类型T的一个前向声明就可以了。这个构造函数不会抛出异常。

~scoped\_ptr()

删除指针所指向的对象。类型T在被销毁时必须是一个完整的类型。如果scoped\_ptr在它被析构时并没有保存资源，它就什么都不做。这个析构函数不会抛出异常。

void reset(T\* p=0);

重置一个 scoped\_ptr 就是删除它已保存的指针，如果它有的话，并重新保存p. 通常，资源的生存期管理应该完全由scoped\_ptr自己处理，但是在极少数时候，资源需要在scoped\_ptr的析构之前释放，或者scoped\_ptr要处理它原有资源之外的另外一个资源。这时，就可以用reset，但一定要尽量少用它。(过多地使用它通常表示有设计方面的问题) 这个函数不会抛出异常。

T& operator\*() const;

该运算符返回一个智能指针中存储的指针所指向的对象的引用。由于不允许空的引用，所以解引用一个拥有空指针的scoped\_ptr将导致未定义行为。如果不能肯定所含指针是否有效，就用函数get替代解引用。这个函数不会抛出异常。

T\* operator->() const;

返回智能指针所保存的指针。如果保存的指针为空，则调用这个函数会导致未定义行为。如果不能肯定指针是否空的，最好使用函数get。这个函数不会抛出异常。

T\* get() const;

返回保存的指针。应该小心地使用get，因为它可以直接操作裸指针。但是，get使得你可以测试保存的指针是否为空。这个函数不会抛出异常。get通常在调用那些需要裸指针的函数时使用。

operator unspecified\_bool\_type() const

返回scoped\_ptr是否为非空。返回值的类型是未指明的，但这个类型可被用于Boolean的上下文（boolean context）中。在if语句中最好使用这个类型转换函数，而不要用get去测试scoped\_ptr的有效性

void swap(scoped\_ptr& b)

交换两个scoped\_ptr的内容。这个函数不会抛出异常。

**普通函数**

template<typename T> void swap(scoped\_ptr<T>& a,scoped\_ptr<T>& b)

这个函数提供了交换两个scoped pointer的内容的更好的方法。之所以说它更好，是因为 swap(scoped1,scoped2) 可以更广泛地用于很多指针类型，包括裸指针和第三方的智能指针。scoped1.swap(scoped2) 则只能用于它的定义所在的智能指针，而不能用于裸指针。

**用法**

**scoped\_ptr的用法与普通的指针没什么区别；最大的差别在于你不必再记得在指针上调用delete，还有复制是不允许的。**典型的指针操作(operator\* 和 operator->)都被重载了，并提供了和裸指针一样的语法。用scoped\_ptr和用裸指针一样快，也没有大小上的增加，因此它们可以广泛使用。使用boost::scoped\_ptr时，包含头文件**"boost/scoped\_ptr.hpp"**. 在声明一个scoped\_ptr时，用被指物的类型来指定类模板的参数。例如，以下是一个包含std::string指针的scoped\_ptr：

boost::scoped\_ptr<std::string> p(new std::string("Hello"));

当scoped\_ptr被销毁时，它对它所拥有的指针调用delete 。

**不需要手工删除**

让我们看一个程序，它使用scoped\_ptr来管理std::string指针。注意这里没有对delete的调用，因为scoped\_ptr是一个自动变量，它会在离开作用域时被销毁。

\#include "**boost/scoped\_ptr.hpp**"  
\#include <string>  
\#include <iostream>  
  
int main() \{  
  \{  
  boost::scoped\_ptr<std::string>   
  p(new std::string("Use scoped\_ptr often."));  
  
  // 打印字符串的值  
  if (p)  
    std::cout << \*p << '/n';  
      
  // 获取字符串的大小  
  size\_t i=p->size();  
  
  // 给字符串赋新值  
  \*p="Acts just like a pointer";  
    
  \} // 这里p被销毁，并删除std::string   
\}

这段代码中有几个地方值得注明一下。首先，scoped\_ptr可以测试其有效性，就象一个普通指针那样，因为它提供了隐式转换到一个可用于布尔表达式的类型的方法。其次，可以象使用裸指针那样调用被指物的成员函数，因为重载了operator->. 第三，也可以和裸指针一样解引用scoped\_ptr，这归功于operator\*的重载。这些特性正是scoped\_ptr和其它智能指针的用处所在，因为它们和裸指针的不同之处在于对生存期管理的语义上，而不在于语法上。

**和auto\_ptr几乎一样**

scoped\_ptr 与 auto\_ptr间的区别主要在于对拥有权的处理。auto\_ptr在复制时会从源auto\_ptr自动交出拥有权，而scoped\_ptr则不允许被复制。看看下面这段程序，它把scoped\_ptr 和 auto\_ptr放在一起，你可以清楚地看到它们有什么不同。

void scoped\_vs\_auto() \{  
  
  using boost::scoped\_ptr;  
  using std::auto\_ptr;  
  
  scoped\_ptr<std::string> p\_scoped(new std::string("Hello"));  
  auto\_ptr<std::string> p\_auto(new std::string("Hello"));  
  
  p\_scoped->size();  
  p\_auto->size();  
  
  scoped\_ptr<std::string> p\_another\_scoped=p\_scoped;  
  auto\_ptr<std::string> p\_another\_auto=p\_auto;  
  
  p\_another\_auto->size();  
  (\*p\_auto).size();  
\}

这个例子不能通过编译，因为scoped\_ptr不能被复制构造或被赋值。auto\_ptr既可以复制构造也可以赋值，这意味着它把所有权从p\_auto 转移给了 p\_another\_auto, 在赋值后p\_auto将只剩下一个空指针。这可能会导致令人不快，就象你试图把auto\_ptr放入容器内时所发生的那样。如果我们删掉对p\_another\_scoped的赋值，程序就可以编译了，但它的运行结果是不可预测的，因为它解引用了p\_auto里的空指针(\*p\_auto).

由于scoped\_ptr::get会返回一个裸指针，所以就有可能对scoped\_ptr做一些有害的事情，其中有两件是你尤其要避免的。第一，不要删除这个裸指针。因为它会在scoped\_ptr被销毁时再一次被删除。第二，不要把这个裸指针保存到另一个scoped\_ptr (或其它任何的智能指针)里。因为这样也会两次删除这个指针，每个scoped\_ptr一次。简单地说，尽量少用get, 除非你要使用那些要求你传送裸指针的遗留代码！

**scoped\_ptr 和Pimpl用法**

scoped\_ptr可以很好地用于许多以前使用裸指针或auto\_ptr的地方，如在实现pimpl用法时。\[4\]pimpl 用法背后的思想是把客户与所有关于类的私有部分的知识分隔开。由于客户是依赖于类的头文件的，头文件中的任何变化都会影响客户，即使仅是对私有段或保护段的修改。pimpl用法隐藏了这些细节，方法是将私有数据和函数放入一个单独的类中，并保存在一个实现文件中，然后在头文件中对这个类进行前向声明并保存一个指向该实现类的指针。类的构造函数分配这个pimpl类，而析构函数则释放它。这样可以消除头文件与实现细节的相关性。我们来构造一个实现pimpl 用法的类，然后用智能指针让它更为安全。

// pimpl\_sample.hpp  
  
\#if !defined (PIMPL\_SAMPLE)  
\#define PIMPL\_SAMPLE  
  
class pimpl\_sample \{  
  struct impl;  // 译者注：原文中这句在class之外，与下文的实现代码有矛盾  
  impl\* pimpl\_;  
public:  
  pimpl\_sample();  
  ~pimpl\_sample();  
  void do\_something();  
\};  
  
\#endif

这是pimpl\_sample类的接口。struct impl 是一个前向声明，它把所有私有成员和函数放在另一个实现文件中。这样做的效果是使客户与pimpl\_sample类的内部细节完全隔离开来。

// pimpl\_sample.cpp   
  
\#include "pimpl\_sample.hpp"  
\#include <string>  
\#include <iostream>  
  
struct pimpl\_sample::impl \{  
  void do\_something\_() \{  
    std::cout << s\_ << "/n";  
  \}  
  
  std::string s\_;  
\};  
  
pimpl\_sample::pimpl\_sample()  
  : pimpl\_(new impl) \{  
  pimpl\_->s\_ = "This is the pimpl idiom";  
\}  
  
pimpl\_sample::~pimpl\_sample() \{  
  delete pimpl\_;  
\}  
  
void pimpl\_sample::do\_something() \{  
  pimpl\_->do\_something\_();  
\}

看起来很完美，但并不是的。这个实现不是异常安全的！原因是pimpl\_sample的构造函数有可能在pimpl被构造后抛出一个异常。在构造函数中抛出异常意味着已构造的对象并不存在，因此在栈展开时将不会调用它的析构函数。这样就意味着分配给pimpl\_指针的内存将泄漏。然而，有一样简单的解决方法：用scoped\_ptr来解救！

class pimpl\_sample \{  
  struct impl;  
  boost::scoped\_ptr<impl> pimpl\_;  
  ...  
\};

让scoped\_ptr来处理隐藏类impl的生存期管理，并从析构函数中去掉对impl的删除(它不再需要，这要感谢scoped\_ptr)，这样就做完了。但是，你必须记住要手工定义析构函数；原因是在编译器生成隐式析构函数时，类impl还是不完整的，所以它的析构函数不能被调用。如果你用auto\_ptr来保存impl, 你可以编译，但也还是有这个问题，但如果用scoped\_ptr, 你将收到一个错误提示。

要注意的是，如果你使用scoped\_ptr作为一个类的成员，你就必须手工定义这个类的复制构造函数和赋值操作符。原因是scoped\_ptr是不能复制的，因此聚集了它的类也变得不能复制了。

最后一点值得注意的是，如果pimpl实例可以安全地被多个封装类(在这里是pimpl\_sample)的实例所共享，那么用boost::shared\_ptr来管理pimpl的生存期才是正确的选择。用shared\_ptr比用scoped\_ptr的优势在于，不需要手工去定义复制构造函数和赋值操作符，而且可以定义空的析构函数，shared\_ptr被设计为可以正确地用于未完成的类。

**scoped\_ptr 不同于 const auto\_ptr**

留心的读者可能已经注意到auto\_ptr可以几乎象scoped\_ptr一样地工作，只要把auto\_ptr声明为const：

const auto\_ptr<A> no\_transfer\_of\_ownership(new A);

它们很接近，但不是一样。最大的区别在于scoped\_ptr可以被reset, 在需要时可以删除并替换被指物。而对于const auto\_ptr这是不可能的。另一个小一点的区别是，它们的名字不同：尽管const auto\_ptr意思上和scoped\_ptr一样，但它更冗长，也更不明显。当你的词典里有了scoped\_ptr，你就应该使用它，因为它可以更清楚地表明你的意图。如果你想说一个资源是要被限制在作用域里的，并且不应该有办法可以放弃它的所有权，你就应该用 boost::scoped\_ptr.

**总结**

使用裸指针来写异常安全和无错误的代码是很复杂的。使用智能指针来自动地把动态分配对象的生存期限制在一个明确的范围之内，是解决这种问题的一个有效方法，并且提高了代码的可读性、可维护性和质量。scoped\_ptr 明确地表示被指物不能被共享和转移。正如你所看到的，std::auto\_ptr可以从另一个auto\_ptr那里窃取被指物，那怕是无意的，这被认为是auto\_ptr的最大缺点。正是这个缺点使得scoped\_ptr成为auto\_ptr最好的补充。当一个动态分配的对象被传送给scoped\_ptr, 它就成为了这个对象的唯一的拥有者。因为scoped\_ptr几乎总是以自动变量或数据成员来分配的，因此它可以在离开作用域时正确地销毁对象，从而在执行流由于返回语句或异常抛出而离开作用域时，也总能释放它所管理的内存。

在以下情况时使用 scoped\_ptr ：

*  在可能有异常抛出的作用域里使用指针
 *  函数里有几条控制路径
 *  动态分配对象的生存期应被限制于特定的作用域内
 *  异常安全非常重要时(总应如此!)

**scoped\_array**

头文件: "boost/scoped\_array.hpp"

需要动态分配数组时，通常最好用std::vector来实现，但是有两种情形看起来用数组更适合： 一种是为了优化，用vector多少有一些额外的内存和速度开销；另一种是为了某种原因，要求数组的大小必须是固定的。动态分配的数组会遇到与普通指针一样的危险，并且还多了一个(也是最常见的一个)，那就是错误调用delete操作符而不是delete\[\]操作符来释放数组。我曾经在你想象不到的地方见到过这个错误，那也是它常被用到的地方，就是在你自己实现的容器类里！scoped\_array 为数组做了scoped\_ptr为单个对象指针所做的事情：它负责释放内存。区别只在于scoped\_array是用delete\[\] 操作符来做这件事的。

scoped\_array是一个单独的类而不是scoped\_ptr的一个特化，其原因是，因为不可能用元编程技术来区分指向单个对象的指针和指向数组的指针。不管如何努力，也没有人能发现一种可靠的方法，因为数组太容易退化为指针了，这使得没有类型信息可以表示它们是指向数组的。结果，只能由你来负责，使用scoped\_array而不是scoped\_ptr，就如你必须用delete\[\]操作符而不是用delete操作符一样。这样的好处是scoped\_array 负责为你处理释放内存的事情，而你则告诉scoped\_array 我们要处理的是数组，而不是裸指针。

scoped\_array与scoped\_ptr非常相似，不同的是它提供了operator\[\] 来模仿一个裸数组。

scoped\_array 是比普通的动态分配数组更好用。它处理了动态分配数组的生存期管理问题，就如scoped\_ptr管理对象指针的生存期一样。但是记住，多数情况下应该使用std::vector，它更灵活、更强大。只有当你需要确保数组的大小是固定的时候，才使用scoped\_array 来替代 std::vector.

**[auto\_ptr解析][auto_ptr]**

auto\_ptr是当前C++标准库中提供的一种智能指针，或许相对于boost库提供的一系列眼花缭乱的智能指针，这个不怎么智能的智能指针难免会黯然失色。诚然，auto\_ptr有这样那样的不如人意，以至于程序员必须像使用”裸“指针那样非常小心地使用它才能保证不出错，以至于它甚至无法适用于同是标准库中的那么多的容器和一些算法，但即使如此，我们仍然不能否认这个小小的auto\_ptr所蕴含的价值与理念。  
　　auto\_ptr的出现，主要是为了解决“被异常抛出时发生资源泄漏”的问题，即如果我们让资源在局部对象构造时分配，在局部对象析构时释放。这样即使在函数执行过程时发生异常而退出，也会因为异常能保证局部对象被析构从而保证资源被释放。auto\_ptr就是基于这个理念而设计，这最早出现在C++之父Bjarne Stroustrup的两本巨著TC++PL和D&E中,其主题为"resource acquisition is initialization"(raii,资源获取即初始化)，然后又在Scott Meyer的《More Effective C++》中相关章节的推动下，被加入了C++标准库。  
　　下面我就列出auto\_ptr的源代码，并详细讲解每一部分。因为标准库中的代码要考虑不同编译器支持标准的不同而插入了不少预编译判断，而且命名可读性不是很强（即使是侯捷老师推荐的SGI版本的stl,可读性也不尽如人意），这里我用了Nicolai M. Josuttis(《The C++ standard library》作者)写的一个auto\_ptr的版本，并做了少许格式上的修改以易于分析阅读：

namespace std \{

// auxiliary type to enable copies and assignments (now global)

template<class Y>

struct auto\_ptr\_ref \{

Y\* yp;

auto\_ptr\_ref (Y\* rhs):yp(rhs) \{

\};

template<class T>

class **auto\_ptr** \{

**private**:

T\* ap;    // refers to the actual owned object (if any)

**public**:

typedef T element\_type;

//** ****构造函数**

explicit auto\_ptr (T\* ptr = 0) throw()

: ap(ptr) \{

// **析构函数**

~auto\_ptr() throw() \{

delete ap;

// **拷贝构造函数**

auto\_ptr (auto\_ptr& rhs) throw()

: ap(rhs.release()) \{

template<class Y>

auto\_ptr (auto\_ptr<Y>& rhs) throw()

: ap(rhs.release()) \{

// **赋值操作符**

auto\_ptr& operator= (auto\_ptr& rhs) throw() \{

reset(rhs.release());

return \*this;

template<class Y>

auto\_ptr& operator= (auto\_ptr<Y>& rhs) throw() \{

reset(rhs.release());

return \*this;

// value access

T\* get() const throw() \{

return ap;

T& operator\*() const throw() \{

return \*ap;

T\* operator->() const throw() \{

return ap;

// release ownership

T\* release() throw() \{

T\* tmp(ap);

ap = 0;

return tmp;

// reset value

void reset (T\* ptr=0) throw() \{

if (ap != ptr) \{

delete ap;

ap = ptr;

/\* special conversions with auxiliary type to enable copies and assignments\*/

auto\_ptr(auto\_ptr\_ref<T> rhs) throw()

: ap(rhs.yp) \{

auto\_ptr& operator= (auto\_ptr\_ref<T> rhs) throw() \{  // new

reset(rhs.yp);

return \*this;

template<class Y>

operator auto\_ptr\_ref<Y>() throw() \{

return auto\_ptr\_ref<Y>(release());

template<class Y>

operator auto\_ptr<Y>() throw() \{

return auto\_ptr<Y>(release());

\};

**1 构造函数与析构函数**

**备注：C++支持两种初始化变量的方式：复制初始化（copy-initialization）和直接初始化（dierct-initialization）；复制初始化语法用等号，直接初始化则是把初始化式放在括号中（《c++ primer 4th》p42）：  
int ival(1024);     //直接初始化  
int ival = 1024;    //复制初始化**

auto\_ptr<>不允许使用一般指针惯用的初始化方式，你必须直接初始化(《stl标准程序库》p40)：   
std::auto\_ptr<ClassA> ptr1(new ClassA);  //OK  
std::auto\_ptr<ClassA> ptr2 = new ClassA; //ERROR

只有auto\_ptr可以拿来当做另外一个auto\_ptr的初始值，普通指针是不行的(《stl标准程序库》p41)：  
std::auto\_ptr<ClassA> ptr;   
ptr = new ClassA;                              //ERROR  
ptr = std::auto\_ptr<ClassA>(new ClassA);  //ok delete old object and own new

在使用auto\_ptr时，有几点需要注意的地方：  
1)** auto\_ptr是这样一种指针，它是“它所指向的对象”的拥有者，当身为对象拥有者的auto\_ptr被摧毁时，该对象也将遭到摧毁。auto\_ptr要求一个对象只能有一个拥有者，绝对不应该出现多个auto\_ptr同时拥有一个对象的情况**，像这样：  
int\* p = new int(0);  
auto\_ptr<int> ap1(p);  
auto\_ptr<int> ap2(p);  
因为ap1与ap2都认为指针p是归它管的，在析构时都试图删除p,两次删除同一个对象的行为在C++标准中是未定义的。所以我们必须防止这样使用auto\_ptr。

2) 并**不存在针对array**而设计的auto\_ptr，考虑下面这种用法：  
int\* pa = new int\[10\];  
auto\_ptr<int> ap(pa);  
因为auto\_ptr的析构函数中删除指针用的是delete,而不是delete \[\],所以我们不应该用auto\_ptr来管理一个数组指针。

3) 构造函数的explicit关键词有效阻止从一个“裸”指针隐式转换成auto\_ptr类型。

4) 因为C++保证删除一个空指针是安全的，所以我们没有必要把析构函数写成：  
~auto\_ptr() throw()   
\{  
    if(ap) delete ap;  
\}

**2 拷贝构造与赋值**  
与引用计数型智能指针不同的，auto\_ptr要求其对“裸”指针的完全占有性。也就是说一个”裸“指针不能同时被两个以上的auto\_ptr所拥有。那么，在拷贝构造或赋值操作时，我们必须作特殊的处理来保证这个特性。auto\_ptr的做法是“所有权转移”，即拷贝或赋值的源对象将失去对“裸”指针的所有权，所以，与一般拷贝构造函数、赋值函数不同，auto\_ptr的拷贝构造函数、赋值函数的参数为引用而不是常引用(const reference).当然，一个auto\_ptr也不能同时拥有两个以上的“裸”指针，所以，拷贝或赋值的目标对象将先释放其原来所拥有的对象。下面就auto\_ptr拥有权转移的情况举例进行说明：  
**拷贝构造函数**：  
std::auto\_ptr<ClassA> ptr1(new ClassA); //initialize an auto\_ptr with a new object  
std::auto\_ptr<ClassA> ptr2(ptr1);        //copy th auto\_ptr  
                                                //transfers ownership from ptr1 to ptr2  
在第一个语句中，ptr1拥有那个new出来的对象。在第二个语句中，拥有权从ptr1转移到ptr2。此后ptr2就拥有了那个new出来的对象，而ptr1不再拥有它。这样，对象就只会被delet一次--在ptr2销毁的时候。  
**赋值操作符（赋值函数）**：  
std::auto\_ptr<ClassA> ptr1(new ClassA); //initialize an auto\_ptr with a new object  
std::auto\_ptr<ClassA> ptr2(new ClassA); //create another auto\_ptr  
ptr2 = ptr1;          //assign the auto\_ptr  
                        //delete object owned by ptr2  
                        //transfers ownership from ptr1 to ptr2  
在这里，赋值动作将拥有权从ptr1转移到ptr2，于是，ptr2拥有了先前被ptr1所拥有的那个对象。如果ptr2被赋值前正拥有另外一个对象，赋值动作发生时会调用delete，将该对象删除。

这里的注意点是：  
1) 因为一个auto\_ptr被拷贝或被赋值后，其已经失去对原对象的所有权，这个时候，对这个auto\_ptr的提领(dereference)操作是不安全的。如下:  
int\* p = new int(0);  
auto\_ptr<int> ap1(p);  
auto\_ptr<int> ap2 = ap1;  
cout<<\*ap1; //错误，此时ap1只剩一个null指针在手了  
这种情况较为隐蔽的情形出现在将auto\_ptr作为函数参数按值传递，因为在函数调用过程中在函数的作用域中会产生一个局部对象来接收传入的auto\_ptr(拷贝构造)，这样，传入的实参auto\_ptr就失去了其对原对象的所有权，而该对象会在函数退出时被局部auto\_ptr删除。如下：  
void f(auto\_ptr<int> ap)\{cout<<\*ap;\}  
auto\_ptr<int> ap1(new int(0));  
f(ap1);  
cout<<\*ap1; //错误，经过f(ap1)函数调用，ap1已经不再拥有任何对象了。  
因为这种情况太隐蔽，太容易出错了，所以auto\_ptr作为函数参数按值传递是一定要避免的。或许大家会想到用auto\_ptr的指针或引用作为函数参数或许可以，但是仔细想想，我们并不知道在函数中对传入的auto\_ptr做了什么，如果当中某些操作使其失去了对对象的所有权，那么这还是可能会导致致命的执行期错误。也许，用const reference的形式来传递auto\_ptr会是一个不错的选择。

2)我们可以看到拷贝构造函数提供了一个成员模板，使得可通过型别自动转换，构造出合适的auto\_ptr。例如，根据一个派生类的对象，构造出一个基类对象的auto\_ptr。同样，赋值操作符（赋值函数）也提供了一个成员模板，使得可通过型别自动转换，赋值给合适的auto\_ptr。例如，将一个派生类的对象，赋值给一个基类对象的auto\_ptr。  
class base\{\};  
class derived: public base\{\};  
那么下列代码就可以通过，实现从auto\_ptr<derived>到auto\_ptr<base>的隐式转换，因为derived\*可以转换成base\*类型  
auto\_ptr<base> apbase = auto\_ptr<derived>(new derived);

3) auto\_ptr不满足stl容器对元素的要求。  
auto\_ptr并不满足stl标准容器对元素的最基本要求。因为在拷贝和赋值动作之后，原本的auto\_ptr和新产生的auto\_ptr并不相等。在拷贝和赋值过后，原来的auto\_ptr会交出拥有权，而不是拷贝给新的auto\_ptr。因此绝对不要将auto\_ptr作为标准容器的元素。

**3 提领操作(dereference)**  
提领操作有两个操作，一个是返回其所拥有的对象的引用，另一个是则实现了通过auto\_ptr调用其所拥有的对象的成员。如：  
struct A\{ … \}  
auto\_ptr<A> apa(new A);  
(\*apa).f();  
apa->f();  
当然，　我们首先要确保这个智能指针确实拥有某个对象，否则，这个操作的行为即对空指针的提领是未定义的。

**4 辅助函数**  
1) get用来显式的返回auto\_ptr所拥有的对象指针。我们可以发现，标准库提供的auto\_ptr既不提供从“裸”指针到auto\_ptr的隐式转换(构造函数为explicit),也不提供从auto\_ptr到“裸”指针的隐式转换，从使用上来讲可能不那么的灵活，考虑到其所带来的安全性还是值得的。  
2) release,用来转移所有权。  
3) reset，用来接收所有权，如果接收所有权的auto\_ptr如果已经拥有某对象，必须先释放该对象。

**5 特殊转换**  
auto\_ptr中剩余的部分（辅助型别auto\_ptr\_ref及其相关函数）涉及非常精致的技巧，使我们得以拷贝和赋值non-const auto\_ptrs，却不能拷贝和赋值const auto\_ptr（更加详细的说明，参考《stl标准模板库》P55）。

**6 auto\_ptr运用实例**（《STL标准模板库》p47）：

下面的一个例子展示了auto\_ptr转移拥有权的行为：

\#include <iostream>

\#include <memory>

using namespace std;

/\* define output operator for auto\_ptr

\* - print object value or NULL

\*/

template <class T>

ostream& operator<< (ostream& strm, const auto\_ptr<T>& p)//参数p是常量引用，所以不发生拥有权转移

// does p own an object ?

if (p.get() == NULL) \{

strm << "NULL";         // NO: print NULL

else \{

strm << \*p;             // YES: print the object

return strm;

int main()

auto\_ptr<int> p(new int(42));

auto\_ptr<int> q;

cout << "after initialization:" << endl;

cout << " p: " << p << endl;

cout << " q: " << q << endl;

q = p;

cout << "after assigning auto pointers:" << endl;

cout << " p: " << p << endl;

cout << " q: " << q << endl;

\*q += 13;                   // change value of the object q owns

p = q;

cout << "after change and reassignment:" << endl;

cout << " p: " << p << endl;

cout << " q: " << q << endl;

**输出结果为：**

**after initialization:**

**p: 42**

**q: NULL**

**after assigning auto pointers:**

**p: NULL**

**q: 42**

**after change and reassignment:**

**p: 55**

**q: NULL**

参考资料：

[http://www.cppblog.com/SmartPtr/archive/2008/01/22/27549.html][http_www.cppblog.com_SmartPtr_archive_2008_01_22_27549.html]

《STL标准程序库》P38-58

附“Google C++编程风格指南”关于智能指针是说明：

如果确实需要使用智能指针的话，scoped\_ptr完全可以胜任。在非常特殊的情况下，例如对STL容器中对象，你应该只使用std::tr1::shared\_ptr，任何情况下都不要使用auto\_ptr。

“智能”指针看上去是指针，其实是附加了语义的对象。以scoped\_ptr为例，scoped\_ptr被销毁时，删除了它所指向的对象。shared\_ptr也是如此，而且，shared\_ptr实现了引用计数（reference-counting），从而只有当它所指向的最后一个对象被销毁时，指针才会被删除。

一般来说，我们倾向于设计对象隶属明确的代码，最明确的对象隶属是根本不使用指针，直接将对象作为一个域（field）或局部变量使用。另一种极端是引用计数指针不属于任何对象，这样设计的问题是容易导致循环引用或其他导致对象无法删除的诡异条件，而且在每一次拷贝或赋值时连原子操作都会很慢。

虽然不推荐这么做，但有些时候，引用计数指针是最简单有效的解决方案。

**shared\_ptr解析**

**《超越C++标准库-Boost库导论》**

**头文件: "boost/shared\_ptr.hpp"**

几乎所有稍微复杂点的程序都需要某种形式的引用计数智能指针。这些智能指针让我们不再需要为了管理被两个或多个对象共享的对象的生存期而编写复杂的逻辑。当引用计数降为零，没有对象再需要这个共享的对象时，这个对象就自动被销毁了。引用计数智能指针可以分为侵入式(intrusive)和非侵入式(non-intrusive)两类。前者要求它所管理的类提供明确的函数或数据成员用于管理引用计数。这意味着在类的设计时就必须预见到它将与一个侵入式的引用计数智能指针一起工作，或者重新设计它。非侵入式的引用计数智能指针对它所管理的类没有任何要求。引用计数智能指针拥有与它所存指针有关的内存的所有权。没有智能指针的帮助，对象的共享会存在问题，必须有人负负责删除共享的内存。谁负责？什么时候删除？没有智能指针，你必须在管理的内存之外增加生存期的管理，这意味着在各个拥有者之间存在更强的依赖关系。换言之，没有了重用性并增加了复杂性。

被管理的类可能拥有一些特性使得它更应该与引用计数智能指针一起使用。例如，它的复制操作很昂贵，或者它所代表的有些东西必须被多个实例共享，这些特性都值得去共享所有权。还有一种情形是共享的资源没有一个明确的拥有者。使用引用计数智能指针可以在需要访问共享资源的对象之间共享资源的所有权。引用计数智能指针还让你可以把对象指针存入标准库的容器中而不会有泄漏的风险，特别是在面对异常或要从容器中删除元素的时候。如果你把指针放入容器，你就可以获得多态的好处，可以提高性能(如果复制的代价很高的话)，还可以通过把相同的对象放入多个辅助容器来进行特定的查找。

在你决定使用引用计数智能指针后，你应该选择侵入式的还是非侵入式的？非侵入式智能指针几乎总是更好的选择，由于它们的通用性、不需要修改已有代码，以及灵活性。你可以对你不能或不想修改的类使用非侵入式的引用计数智能指针。而把一个类修改为使用侵入式引用计数智能指针的常见方法是从一个引用计数基类派生。这种修改可能比你想象的更昂贵。至少，它增加了相关性并降低了重用性。它还增加了对象的大小，这在一些特定环境中可能会限制其可用性。

shared\_ptr 可以从一个裸指针、另一个shared\_ptr、一个std::auto\_ptr、或者一个boost::weak\_ptr构造。还可以传递第二个参数给shared\_ptr的构造函数，它被称为删除器(deleter)。删除器稍后会被调用，来处理共享资源的释放。这对于管理那些不是用new分配也不是用delete释放的资源时非常有用(稍后将看到创建自定义删除器的例子)。shared\_ptr被创建后，它就可象普通指针一样使用了，除了一点，它不能被显式地删除。

以下是shared\_ptr的部分摘要；最重要的成员和相关普通函数被列出，随后是简单的讨论。

namespace boost \{  
  template<typename T> class shared\_ptr \{  
  public:  
    template <class Y> **explicit** shared\_ptr(Y\* p);  
    template <class Y,class D> shared\_ptr(Y\* p,D d);  
  
    ~shared\_ptr();  
  
    shared\_ptr(const shared\_ptr & r);  
    template <class Y> explicit shared\_ptr(const weak\_ptr<Y>& r);  
    template <class Y> explicit shared\_ptr(std::auto\_ptr<Y>& r);  
  
    shared\_ptr& operator=(const shared\_ptr& r);  
  
    void reset();   
    
    T& operator\*() const;  
    T\* operator->() const;  
    T\* get() const;  
  
    bool unique() const;  
    long use\_count() const;  
  
    operator unspecified\_bool\_type() const;    
    void swap(shared\_ptr<T>& b);  
  \};  
  
  template <class T,class U>  
    shared\_ptr<T> static\_pointer\_cast(const shared\_ptr<U>& r);  
\}

**成员函数**

template <class Y> explicit shared\_ptr(Y\* p);

这个构造函数获得给定指针p的所有权。参数 p 必须是指向 Y 的有效指针。构造后引用计数设为1。唯一从这个构造函数抛出的异常是std::bad\_alloc (仅在一种很罕见的情况下发生，即不能获得引用计数器所需的自由空间)。

template <class Y,class D> shared\_ptr(Y\* p,D d);

这个构造函数带有两个参数。第一个是shared\_ptr将要获得所有权的那个资源，第二个是shared\_ptr被销毁时负责释放资源的一个对象，所存储的资源将以d(p)的形式传给那个对象。因此p的值是否有效取决于d。如果引用计数器不能分配成功，shared\_ptr抛出一个类型为std::bad\_alloc的异常。

shared\_ptr(const shared\_ptr& r);

r中保存的资源被新构造的shared\_ptr所共享，引用计数加一。这个构造函数不会抛出异常。

template <class Y> explicit shared\_ptr(const weak\_ptr<Y>& r);

从一个weak\_ptr构造shared\_ptr。这使得weak\_ptr的使用具有线程安全性，因为指向weak\_ptr参数的共享资源的引用计数将会自增(weak\_ptr不影响共享资源的引用计数)。如果weak\_ptr为空(r.use\_count()==0), shared\_ptr 抛出一个类型为bad\_weak\_ptr的异常。

template <typename Y> shared\_ptr(std::auto\_ptr<Y>& r);

这个构造函数从一个auto\_ptr获取r中保存的指针的所有权，方法是保存指针的一份拷贝并对auto\_ptr调用release。构造后的引用计数为1。而r当然就变为空的。如果引用计数器不能分配成功，则抛出std::bad\_alloc 。

~shared\_ptr();

shared\_ptr析构函数对引用计数减一。如果计数为零，则保存的指针被删除。删除指针的方法是调用operator delete 或者，如果程序中给定了一个执行删除操作的自定义删除器对象，就把保存的指针作为唯一参数调用这个对象。析构函数不会抛出异常。

shared\_ptr& operator=(const shared\_ptr& r);

赋值操作共享r中的资源，并停止对原有资源的共享。赋值操作不会抛出异常。

void reset();

reset函数用于停止对保存指针的所有权的共享。共享资源的引用计数减一。

T& operator\*() const;

这个操作符返回对已存指针所指向的对象的一个引用。如果指针为空，调用operator\* 会导致未定义行为。这个操作符不会抛出异常。

T\* operator->() const;

这个操作符返回保存的指针。这个操作符与operator\*一起使得智能指针看起来象普通指针。这个操作符不会抛出异常。

T\* get() const;

get函数是当保存的指针有可能为空时(这时 operator\* 和 operator-> 都会导致未定义行为)获取它的最好办法。注意，你也可以使用隐式布尔类型转换来测试 shared\_ptr 是否包含有效指针。这个函数不会抛出异常。

bool unique() const;

这个函数在shared\_ptr是它所保存指针的唯一拥有者时返回 true ；否则返回 false。 unique 不会抛出异常。

long use\_count() const;

use\_count 函数返回指针的引用计数。它在调试的时候特别有用，因为它可以在程序执行的关键点获得引用计数的快照。小心地使用它，因为在某些可能的shared\_ptr实现中，计算引用计数可能是昂贵的，甚至是不行的。这个函数不会抛出异常。

operator unspecified\_bool\_type() const;

这是个到unspecified\_bool\_type类型的隐式转换函数，它可以在Boolean上下文中测试一个智能指针。如果shared\_ptr保存着一个有效的指针，返回值为True；否则为false。注意，转换函数返回的类型是不确定的。把返回类型当成bool用会导致一些荒谬的操作，所以典型的实现采用了safe bool idiom, 它很好地确保了只有可适用的Boolean测试可以使用。这个函数不会抛出异常。

void swap(shared\_ptr<T>& b);

这可以很方便地交换两个shared\_ptr。swap 函数交换保存的指针(以及它们的引用计数)。这个函数不会抛出异常。

**普通函数**

template <typename T,typename U>  
  shared\_ptr<T> static\_pointer\_cast(const shared\_ptr<U>& r);

要对保存在shared\_ptr里的指针执行static\_cast，我们可以取出指针然后强制转换它，但我们不能把它存到另一个shared\_ptr里；新的 shared\_ptr 会认为它是第一个管理这些资源的。解决的方法是用static\_pointer\_cast. 使用这个函数可以确保被指物的引用计数保持正确。static\_pointer\_cast 不会抛出异常。

**用法**

使用shared\_ptr解决的主要问题是知道删除一个被多个客户共享的资源的正确时机。下面是一个简单易懂的例子，有两个类 A 和 B, 它们共享一个int实例。使用 boost::shared\_ptr, 你需要必须包含"boost/shared\_ptr.hpp".

\#include "boost/shared\_ptr.hpp"  
\#include <cassert>  
  
class A \{  
  boost::shared\_ptr<int> no\_;  
public:  
  A(boost::shared\_ptr<int> no) : no\_(no) \{\}  
  void value(int i) \{  
    \*no\_=i;  
  \}  
\};  
  
class B \{  
  boost::shared\_ptr<int> no\_;  
public:  
  B(boost::shared\_ptr<int> no) : no\_(no) \{\}  
  int value() const \{  
    return \*no\_;  
  \}  
\};  
  
int main() \{  
    boost::shared\_ptr<int> temp(new int(14));  
    A a(temp);  
    B b(temp);  
    a.value(28);  
    assert(b.value()==28);  
\}

类 A 和 B都保存了一个 shared\_ptr<int>. 在创建 A 和 B的实例时，shared\_ptr temp 被传送到它们的构造函数。这意味着共有三个 shared\_ptr：a, b, 和 temp，它们都指向同一个int实例。如果我们用指针来实现对同一个int实例的共享，那么A和B表明找出它们所共享的对象何时(是否)被释放非常困难。在这个例子中，直到main的结束，引用计数为3，当所有 shared\_ptr离开了作用域，计数将达到0，而最后一个智能指针将负责删除共享的 int.

**回顾Pimpl用法**

前一节展示了使用scoped\_ptr的pimpl 用法，如果使用这种用法的类是不允许复制的，那么scoped\_ptr在保存pimpl的动态分配实例时它工作得很好。但是这并不适合于所有想从pimpl用法中获益的类型(注意，你还可以用 scoped\_ptr，但必须手工实现复制构造函数和赋值操作符)。对于那些可以处理共享的实现细节的类，应该用 shared\_ptr。当pimpl的所有权被传递给一个 shared\_ptr, 复制和赋值操作都是免费的。你可以回忆起，当使用 scoped\_ptr 去处理pimpl类的生存期时，对封装类的复制是不允许的，因为 scoped\_ptr是不可复制的。这意味着要使这些类支持复制和赋值，你必须手工定义复制构造函数和赋值操作符。当使用 shared\_ptr 去处理pimpl类的生存期时，就不再需要用户自己定义复制构造函数了。注意，这时pimpl实例是被该类的多个对象所共享，因此如果规则是每个pimpl实例只能被类的一个实例使用，你还是要手工编写复制构造函数。解决的方法和我们在scoped\_ptr那看到的很相似，只是把scoped\_ptr换成了shared\_ptr。

**shared\_ptr 与标准库容器**

把对象直接存入容器中有时会有些麻烦。以值的方式保存对象意味着使用者将获得容器中的元素的拷贝，对于那些复制是一种昂贵的操作的类型来说可能会有性能的问题。此外，有些容器，特别是std::vector, 当你加入元素时可能会复制所有元素，这更加重了性能的问题。最后，传值的语义意味着没有多态的行为。如果你需要在容器中存放多态的对象而且你不想切割它们，你必须用指针。如果你用裸指针，维护元素的完整性会非常复杂。从容器中删除元素时，你必须知道容器的使用者是否还在引用那些要删除的元素，不用担心多个使用者使用同一个元素。这些问题都可以用shared\_ptr来解决。下面是如何把共享指针存入标准库容器的例子。

\#include "boost/shared\_ptr.hpp"  
\#include <vector>  
\#include <iostream>  
  
**class A** \{  
public:  
  virtual void sing()=0;  
protected:  
  virtual ~A() \{\};  
\};  
  
**class B** : public A \{  
public:  
  virtual void sing() \{  
    std::cout << "Do re mi fa so la";  
  \}  
\};  
  
boost::shared\_ptr<A> createA() \{  
  boost::shared\_ptr<A> p(new B());  
  return p;  
\}  
  
int main() \{  
  typedef std::vector<boost::shared\_ptr<A> > container\_type;  
  typedef container\_type::iterator iterator;  
  
  container\_type container;  
  for (int i=0;i<10;++i) \{  
    container.push\_back(createA());  
  \}  
  
  std::cout << "The choir is gathered: /n";  
  iterator end=container.end();  
  for (iterator it=container.begin();it!=end;++it) \{  
    (\*it)->sing();  
  \}  
\}

这里有两个类, A 和 B, 各有一个虚拟成员函数 sing. B 从 A公有继承而来，并且如你所见，工厂函数createA 返回一个动态分配的B的实例，包装在shared\_ptr<A>里。在 main里, 一个包含shared\_ptr<A>的 std::vector 被放入10个元素，最后对每个元素调用sing。如果我们用裸指针作为元素，那些对象需要被手工删除。而在这个例子里，删除是自动的，因为在vector的生存期中，每个shared\_ptr的引用计数都保持为1；当 vector 被销毁，所有引用计数器都将变为零，所有对象都被删除。有趣的是，即使 A 的析构函数没有声明为 virtual, shared\_ptr 也会正确调用 B的析构函数！

上面的例子示范了一个强有力的技术，它涉及A里面的protected析构函数。因为函数 createA 返回的是 shared\_ptr<A>, 因此不可能对shared\_ptr::get返回的指针调用 delete 。这意味着如果为了向某个需要裸指针的函数传送裸指针而从shared\_ptr中取出裸指针的话，它不会由于意外地被删除而导致灾难。那么，又是如何允许 shared\_ptr 删除它的对象的呢？ 这是因为指针指向的真正类型是 B; 而B的析构函数不是protected的。这是非常有用的方法，用于给shared\_ptr中的对象增加额外的安全性。

**shared\_ptr 与其它资源**

有时你会发现你要把shared\_ptr用于某个特别的类型，它需要其它清除操作而不是简单的delete. shared\_ptr可以通过自定义删除器来支持这种需要。那些处理象 FILE\*这样的操作系统句柄的资源通常要使用象fclose这样的操作来释放。要在shared\_ptr里使用 FILE\* ，我们要定义一个类来负责释放相应的资源。

class FileCloser \{  
public:  
   void operator()(FILE\* file) \{  
    std::cout << "The FileCloser has been called with a FILE\*, "  
      "which will now be closed./n";  
    if (file!=0)   
      fclose(file);  
  \}  
\};

这是一个函数对象，我们用它来确保在资源要释放时调用 fclose 。下面是使用FileCloser类的示例程序。

int main() \{  
  std::cout << "shared\_ptr example with a custom deallocator./n";   
  \{  
    FILE\* f=fopen("test.txt","r");  
    if (f==0) \{  
      std::cout << "Unable to open file/n";  
      throw "Unable to open file";  
    \}  
  
    boost::shared\_ptr<FILE> my\_shared\_file(f, FileCloser());  
  
    // 定位文件指针  
    fseek(my\_shared\_file.get(),42,SEEK\_SET);  
  \}  
  std::cout << "By now, the FILE has been closed!/n";  
\}

注意，在访问资源时，我们需要对shared\_ptr使用 &\* 用法, get, 或 get\_pointer。(请注意最好使用&\*. 另两个选择不太清晰) 这个例子还可以更简单，如果我们在释放资源时只需要调用一个单参数函数的话，就根本不需要创建一个自定义删除器类型。上面的例子可以重写如下：

\{  
  FILE\* f=fopen("test.txt","r");  
  if (f==0) \{  
    std::cout << "Unable to open file/n";  
    throw file\_exception();  
  \}  
    
  boost::shared\_ptr<FILE> my\_shared\_file(f,&fclose);  
  
  // 定位文件指针  
  fseek(&\*my\_shared\_file,42,SEEK\_SET);   
\}  
std::cout << "By now, the FILE\* has been closed!/n";

自定义删除器在处理需要特殊释放程序的资源时非常有用。由于删除器不是 shared\_ptr 类型的一部分，所以使用者不需要知道关于智能指针所拥有的资源的任何信息(当然除了如何使用它！)。例如，你可以使用对象池，定制删除器只需简单地把对象返还到池中。或者，一个 singleton 对象应该使用一个什么都不做的删除器。

**使用定制删除器的安全性**

我们已经看到对基类使用 protected 析构函数有助于增加使用shared\_ptr的类的安全性。另一个达到同样安全级别的方法是，声明析构函数为 protected (或 private) 并使用一个定制删除器来负责销毁对象。这个定制删除器必须是它要删除的类的友元，这样它才可以工作。封装这个删除器的好方法是把它实现为私有的嵌套类，如下例所示：

\#include "boost/shared\_ptr.hpp"  
\#include <iostream>  
  
class A \{  
  class deleter \{  
    public:  
      void operator()(A\* p) \{  
        delete p;  
      \}  
  \};  
  friend class deleter;  
public:  
  virtual void sing() \{  
    std::cout << "Lalalalalalalalalalala";  
  \}  
  
  static boost::shared\_ptr<A> createA() \{  
    boost::shared\_ptr<A> p(new A(),A::deleter());  
    return p;  
  \}  
  
protected:  
  virtual ~A() \{\};  
\};  
  
int main() \{  
  boost::shared\_ptr<A> p=A::createA();  
\}

注意，我们在这里不能使用普通函数来作为 shared\_ptr<A> 的工厂函数，因为嵌套的删除器是A私有的。使用这个方法，用户不可能在栈上创建 A的对象，也不可能对A的指针调用 delete 。

**从this创建shared\_ptr  **

有时候，需要从this获得 shared\_ptr，即是说，你希望你的类被shared\_ptr所管理，你需要把"自身"转换为shared\_ptr的方法。看起来不可能？好的，解决方案来自于我们即将讨论的另一个智能指针boost::weak\_ptr. weak\_ptr 是 shared\_ptr的一个观察者；它只是安静地坐着并看着它们，但不会影响引用计数。通过存储一个指向this的 weak\_ptr 作为类的成员，就可以在需要的时候获得一个指向this的 shared\_ptr。为了你可以不必编写代码来保存一个指向this的 weak\_ptr，接着又从weak\_ptr获得shared\_ptr，Boost.Smart\_ptr 为此提供了一个助手类，称为 enable\_shared\_from\_this. 只要简单地让你的类公有地派生自 enable\_shared\_from\_this，然后在需要访问管理this的shared\_ptr时，使用函数 shared\_from\_this 就行了。下面的例子示范了如何使用 enable\_shared\_from\_this ：

\#include "boost/shared\_ptr.hpp"  
\#include "boost/enable\_shared\_from\_this.hpp"  
  
class A;  
  
void do\_stuff(boost::shared\_ptr<A> p) \{  
  ...  
\}  
  
class A : public boost::enable\_shared\_from\_this<A> \{  
public:  
  void call\_do\_stuff() \{  
    do\_stuff(shared\_from\_this());  
  \}  
\};  
  
int main() \{  
  boost::shared\_ptr<A> p(new A());  
  p->call\_do\_stuff();  
\}

这个例子还示范了你要用shared\_ptr管理this的情形。类 A 有一个成员函数 call\_do\_stuff 需要调用一个普通函数 do\_stuff, 这个普通函数需要一个类型为 boost:: shared\_ptr<A>的参数。现在，在A::call\_do\_stuff里, this 不过是一个 A指针, 但由于 A 派生自 enable\_shared\_from\_this, 调用shared\_from\_this 将返回我们所要的 shared\_ptr 。在enable\_shared\_from\_this的成员函数shared\_from\_this里，内部存储的 weak\_ptr 被转换为 shared\_ptr, 从而增加了相应的引用计数，以确保相应的对象不会被删除。

**总结**

引用计数智能指针是非常重要的工具。Boost的 shared\_ptr 提供了坚固而灵活的解决方案，它已被广泛用于多种环境下。需要在使用者之间共享对象是常见的，而且通常没有办法通知使用者何时删除对象是安全的。shared\_ptr 让使用者无需知道也在使用共享对象的其它对象，并让它们无需担心在没有对象引用时的资源释放。这对于Boost的智能指针类而言是最重要的。你会看到Boost.Smart\_ptr中还有其它的智能指针，但这一个肯定是你最想要的。通过使用自定义删除器，几乎所有资源类型都可以存入shared\_ptr。这使得shared\_ptr 成为处理资源管理的通用类，而不仅仅是处理动态分配对象。与裸指针相比，shared\_ptr会有一点点额外的空间代价。我还没有发现由于这些代价太大而需要另外寻找一个解决方案的情形。不要去创建你自己的引用计数智能指针类。没有比使用 shared\_ptr智能指针更好的了。

在以下情况时使用 shared\_ptr ：

*  当有多个使用者使用同一个对象，而没有一个明显的拥有者时
 *  当要把指针存入标准库容器时
 *  当要传送对象到库或从库获取对象，而没有明确的所有权时
 *  当管理一些需要特殊清除方式的资源时\[9\]

**shared\_array**

头文件: "boost/shared\_array.hpp"

shared\_array 用于共享数组所有权的智能指针。它与shared\_ptr的关系就如scoped\_array与scoped\_ptr的关系。shared\_array 与 shared\_ptr 的不同之处主要在于它是用于数组的而不是用于单个对象的。在我们讨论 scoped\_array时，我提到过通常std::vector是一个更好的选择。但shared\_array 比 vector更有价值，因为它提供了对数组所有权的共享。shared\_array 的接口与shared\_ptr非常相似，差别仅在于增加了一个下标操作符，以及不支持定制删除器。

由于一个指向std::vector的shared\_ptr提供了比shared\_array更多的灵活性，所以我们就不对shared\_array的用法进行讨论了。如果你发现自己需要 boost::shared\_array, 可以参考一下在线文档。

[auto_ptr]: http://www.cppblog.com/SmartPtr/archive/2007/07/05/27549.html
[http_www.cppblog.com_SmartPtr_archive_2008_01_22_27549.html]: http://www.cppblog.com/SmartPtr/archive/2008/01/22/27549.html