智能指针scoped_ptr

对应C++11中的unique_ptr

 

 

 

#include <iostream>
#include <memory>

class foo
{
    public:
        foo() { std::cout<<"constructor"<<std::endl;}
        ~foo() { std::cout<<"destructor"<<std::endl; }

        void doit() { std::cout<<"do"<<std::endl; }
};

int main()
{
    std::unique_ptr<foo> sf(new foo);
    sf->doit();
    (*sf).doit();

    sf.reset(new foo);
    sf->doit();

    return 0;
}

 

　　

 

 

scoped_ptr的所有权更加严格，不允许转让，对其赋值和拷贝都是不合法行为，因而显得更轻巧和快捷。

scoped_ptr重载了operator*()和operator->()解引用操作符*和箭头操作符->,因此可以把scoped_ptr对象如同指针一样使用。如果scoped_ptr保存的空指针，那么这两个操作的行为未定义。

scoped_ptr不能在两个scoped_ptr之间、scoped_ptr与原始指针之间或空指针之间进行了相等或不相等测试。operator ==和operator !=都被声明为私有。

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类。

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

    

template<class T> class scoped_ptr // noncopyable
{
private:

    T * px;
    scoped_ptr(scoped_ptr const &);
    scoped_ptr & operator=(scoped_ptr const &);
    typedef scoped_ptr<T> this_type;
    void operator==( scoped_ptr const& ) const;
    void operator!=( scoped_ptr const& ) const;

public:

    typedef T element_type;
    explicit scoped_ptr( T * p = 0 ); // never throws
    explicit scoped_ptr( std::auto_ptr<T> p ); // never throws

    ~scoped_ptr() // never throws在其作用域结束时自动删除保存的指针对象，从而正确地回收资源
    void reset(T * p = 0) // never throws删除原来保存的指针，再保存新的指针p，如果p是空指针，那scoped_ptr将不持有任何指针
    {
        BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
        this_type(p).swap(*this);
    }

    T & operator*() const // never throws
    {
        BOOST_ASSERT( px != 0 );
        return *px;
    }

    T * operator->() const // never throws
    {
        BOOST_ASSERT( px != 0 );
        return px;
    }

    T * get() const // never throws返回scoped_ptr内部保存的原始指针
    {
        return px;
    }

    void swap(scoped_ptr & b);// never throws交换两个scoped_ptr保存的原始指针
};