Boost 智能指针-白红宇

Boost 智能指针

阅读量：6163 次

发布时间：2019-06-21

本文共 5954 字，大约阅读时间需要 19 分钟。

1. auto_ptr

auto_ptr 类可以用于管理由 new 分配的单个对象，但是无法管理动态分配的数组（我们通常不会使用数组，而是使用 vector 代替数组）。auto_ptr 在拷贝和赋值的时候有不寻常的行为，因此 auto_ptrs 不能被保存在 stl 的容器中。当 auto_ptr 离开了自己的作用域或者被销毁，由 auto_ptr 管理的对象也会被销毁。

// 示例 1(b): 安全代码, 使用了auto_ptr#include 
    
     void f(){　 auto_ptr
     
       pt( new T );   .....} // 当pt出了作用域时析构函数被调用，从而对象被自动删除

现在代码不会泄漏T类型的对象，不管这个函数是正常退出还是抛出了异常，因为pt的析构函数总是会在出栈时被调用，清理会自动进行。

　　最后，使用一个auto_ptr就像使用一个内建的指针一样容易，而且如果想要手动“撤销”资源的所有权，我们只要调用release().

// 示例 2: 使用一个 auto_ptr#include 
    
     void g(){    T* pt1 = new T;  // 现在，我们有了一个分配好的对象    auto_ptr
     
       auto_pt2( pt1 ); // 将所有权传给了一个auto_ptr对象,auto_pt2 指向了 pt1    // 使用auto_ptr就像我们以前使用简单指针一样    auto_pt2 = 12; // 就像 "*pt1 = 12;"    auto_pt2->SomeFunc(); // 就像 "pt1->SomeFunc();"    // 用get()来获得指针的值    assert( pt1 == auto_pt2.get() );  // 二者一样    // 用release()来撤销所有权， auto_pt2 把保存的指针地址给了pt3, 而自己指向了NUll。    T* pt3 = auto_pt2.release();  //    // 自己删除这个对象，因为现在没有任何auto_ptr拥有这个对象    delete pt3;} // pt2不再拥有任何指针，所以不要试图删除它...ok，不要重复删除

最后，我们可以使用auto_ptr的reset()函数来重置auto_ptr使之拥有另一个对象。如果这个auto_ptr已经拥有了一个对象，那么，它会先删除已经拥有的对象，因此调用reset()就如同销毁这个auto_ptr，然后新建一个并拥有一个新对象：

// 示例 3: 使用reset()#include 
    
     void h(){　　 auto_ptr
     
       pt( new T(1) );　　 pt.reset( new T(2) );  //即pt会首先delete pt目前指向的地址（new T(1)得到的地址)，                            //然后再指向new T(2)分配的地址} // 最后，pt出了作用域，第二个T也被自动删除了

2. scoped_ptr

boost::scoped_ptr和std::auto_ptr非常类似，是一个简单的智能指针，它能够保证在离开作用域后对象被自动释放。下列代码演示了该指针的基本应用：

#include 
    
     #include 
     
      #include 
      
       class implementation{public:    ~implementation() { std::cout <<"destroying implementation\n"; }    void do_something() { std::cout << "did something\n"; }};void test(){    boost::scoped_ptr
       
         impl(new implementation());    impl->do_something();}void main(){    std::cout<<"Test Begin ... \n";    test();    std::cout<<"Test End.\n";}

该代码的输出结果是：

Test Begin ...

did something

destroying implementation

Test End.

可以看到：当implementation类离其开impl作用域的时候，会被自动删除，这样就会避免由于忘记手动调用delete而造成内存泄漏了。

boost::scoped_ptr的实现和std::auto_ptr非常类似，都是利用了一个栈上的对象去管理一个堆上的对象，从而使得堆上的对象随着栈上的对象销毁时自动删除。不同的是，boost::scoped_ptr有着更严格的使用限制——不能拷贝。这就意味着：boost::scoped_ptr指针是不能转换其所有权的

boost::scoped_ptr特点：

(1) 不能转换所有权

boost::scoped_ptr所管理的对象生命周期仅仅局限于一个区间（该指针所在的"{}"之间），无法传到区间之外，这就意味着boost::scoped_ptr对象是不能作为函数的返回值的（std::auto_ptr可以）。

(2) 不能共享所有权

这点和std::auto_ptr类似。这个特点一方面使得该指针简单易用。另一方面也造成了功能的薄弱——不能用于stl的容器中。

(3) 不能用于管理数组对象

由于boost::scoped_ptr是通过 delete来删除所管理对象的，而数组对象必须通过 deletep[]来删除，因此boost::scoped_ptr是不能管理数组对象的，如果要管理数组对象需要使用boost::scoped_array类。

boost::scoped_ptr的常用操作：

成员函数	功能
operator*()	以引用的形式访问所管理的对象的成员
operator->()	以指针的形式访问所管理的对象的成员
get()	释放所管理的对象，管理另外一个对象
swap(scoped_ptr& b)	交换两个boost::scoped_ptr管理的对象

下列测试代码演示了这些功能函数的基本使用方法。

#include 
    
     #include 
     
      #include 
      
       #include 
       
        #include 
        
         #include 
         
          void test(){    // test scoped_ptr with a built-in type    long * lp = new long;    boost::scoped_ptr
          
            sp ( lp );    BOOST_TEST( sp.get() == lp );    BOOST_TEST( lp == sp.get() );    BOOST_TEST( &*sp == lp );    *sp = 1234568901L;    BOOST_TEST( *sp == 1234568901L );    BOOST_TEST( *lp == 1234568901L );    long * lp2 = new long;    boost::scoped_ptr
           
             sp2 ( lp2 );    sp.swap(sp2);    BOOST_TEST( sp.get() == lp2 );    BOOST_TEST( sp2.get() == lp );    sp.reset(NULL);    BOOST_TEST( sp.get() == NULL );}void main(){    test();}

boost::scoped_ptr和std::auto_ptr的选取：

boost::scoped_ptr和std::auto_ptr的功能和操作都非常类似，如何在他们之间选取取决于是否需要转移所管理的对象的所有权（如是否需要作为函数的返回值）。如果没有这个需要的话，大可以使用boost::scoped_ptr，让编译器来进行更严格的检查，来发现一些不正确的赋值操作。

3. shared_ptr

boost::scoped_ptr虽然简单易用，但它不能共享所有权的特性却大大限制了其使用范围，而boost::shared_ptr可以解决这一局限。顾名思义，boost::shared_ptr是可以共享所有权的智能指针，首先让我们通过一个例子看看它的基本用法：

#include 
    
     #include 
     
      #include 
      
       class implementation{public:    ~implementation() { std::cout <<"destroying implementation\n"; }    void do_something() { std::cout << "did something\n"; }};void test(){    boost::shared_ptr
       
         sp1(new implementation());    std::cout<<"The Sample now has "<
        
         <<" references\n";    boost::shared_ptr
         
           sp2 = sp1;    std::cout<<"The Sample now has "<
          
           <<" references\n";        sp1.reset();    std::cout<<"After Reset sp1. The Sample now has "<
           
            <<" references\n";    sp2.reset();    std::cout<<"After Reset sp2.\n";}void main(){    test();}

该程序的输出结果如下：

The Sample now has 1 references

The Sample now has 2 references

After Reset sp1. The Sample now has 1 references

destroying implementation

After Reset sp2.

可以看到，boost::shared_ptr指针sp1和sp2同时拥有了implementation对象的访问权限，且当sp1和sp2都释放对该对象的所有权时，其所管理的的对象的内存才被自动释放。在共享对象的访问权限同时，也实现了其内存的自动管理。

boost::shared_ptr的内存管理机制：

boost::shared_ptr的管理机制其实并不复杂，就是对所管理的对象进行了引用计数，当新增一个boost::shared_ptr对该对象进行管理时，就将该对象的引用计数加一；减少一个boost::shared_ptr对该对象进行管理时，就将该对象的引用计数减一，如果该对象的引用计数为0的时候，说明没有任何指针对其管理，才调用delete释放其所占的内存。

上面的那个例子可以的图示如下：

sp1对implementation对象进行管理，其引用计数为1

增加sp2对implementation对象进行管理，其引用计数增加为2

sp1释放对implementation对象进行管理，其引用计数变为1

sp2释放对implementation对象进行管理，其引用计数变为0，该对象被自动删除

boost::shared_ptr的特点：

和前面介绍的boost::scoped_ptr相比，boost::shared_ptr可以共享对象的所有权，因此其使用范围基本上没有什么限制（还是有一些需要遵循的使用规则，下文中介绍），自然也可以使用在stl的容器中。另外它还是线程安全的，这点在多线程程序中也非常重要。

boost::shared_ptr的使用规则：

boost::shared_ptr并不是绝对安全，下面几条规则能使我们更加安全的使用boost::shared_ptr：

(1) 避免对shared_ptr所管理的对象的直接内存管理操作，以免造成该对象的重释放

(2) shared_ptr并不能对循环引用的对象内存自动管理（这点是其它各种引用计数管理内存方式的通病）。

(3) 不要构造一个临时的shared_ptr作为函数的参数。

如下列代码则可能导致内存泄漏：

void test(){    foo(boost::shared_ptr
    
     (new    implementation()),g());}正确的用法为：void test(){    boost::shared_ptr
     
       sp    (new implementation());    foo(sp,g());}