发布日期:2016-02-29 13:21 来源: 标签: 编程语言 C++开发语言 C++指针类 C++模板类
智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联,引用计数跟踪该类有多少个对象的指针指向同一对象。引用计数为0时,删除对象。

智能指针类

引用计数

智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联,引用计数跟踪该类有多少个对象的指针指向同一对象。引用计数为0时,删除对象。
其基本使用规则是:
每次创建类的新对象时,初始化指针并将引用计数置为1。当对象作为另一对象的副本而创建时,复制构造函数复制指针并增加与之相应的引用计数的值。对一个对象进行赋值时,赋值操作符减少左操作数所指对象的引用计数的值(如果引用计数减至0,则删除对象),并增加右操作数所指对象的引用计数的值。最后,调用析构函数时,析构函数减少引用计数的值,如果计数减至0,则删除基础对象。
实现引用计数有两种经典策略:一是引入辅助类(包含引用计数型),二是使用句柄类(分离引用计数型)

策略1:引用计数类

这个类的所有成员均为 private。我们不希望用户使用 U_Ptr 类,所以它没有任何 public 成员。将 HasPtr 类设置为友元, 使其成员可以访问 U_Ptr 的成员。
U_Ptr 类保存指针和使用计数,每个 HasPtr 对象将指向一个 U_Ptr 对象,使用计数将跟踪指向每个U_Ptr 对象的 HasPtr 对象的数目。U_Ptr 定义的仅有函数是构造函数和析构函数,构造函数复制指针,而析构函数删除它。构造函数还将使用计数置为 1,表示一个 HasPtr 对象指向这个 U_Ptr 对象。

class U_Ptr
{
    friend class HasPtr;
    int *ip;
    int use;

    U_Ptr(int *p):ip(p){}
    ~U_Ptr()
    {
        delete ip;
    }
};
class HasPtr
{
public:
    HasPtr(int *p, int i):_ptr(new U_Ptr(p)),_val(i)
    {}
    HasPtr(const HasPtr& obj):_ptr(obj._ptr),_val(obj._val)
    {
        ++_ptr->use;
    }
    HasPtr& operator=(const HasPtr&);
    ~HasPtr()
    {
        if(--_ptr->use == 0)
            delete _ptr;
    }
private:
    U_Ptr* _ptr;
    int _val;
};

接受一个指针和一个 int 值的 HasPtr 构造函数使用其指针形参创建一个新的 U_Ptr 对象。HasPtr 构造函数执行完毕后,HasPtr 对象指向一个新分配的 U_Ptr 对象,该 U_Ptr 对象存储给定指针。新 U_Ptr 中的使用计数为 1,表示只有一个 HasPtr 对象指向它。
复制构造函数从形参复制成员并增加使用计数的值。复制构造函数执行完毕后,新创建对象与原有对象指向同一 U_Ptr 对象,该 U_Ptr 对象的使用计数加1。
析构函数将检查 U_Ptr 基础对象的使用计数。如果使用计数为 0,则这是最后一个指向该 U_Ptr 对象的 HasPtr 对象,在这种情况下,HasPtr 析构函数删除其 U_Ptr 指针。删除该指针将引起对 U_Ptr 析构函数的调用,U_Ptr 析构函数删除 int 基础对象。

赋值与引用计数
首先将右操作数中的使用计数加 1,然后将左操作数对象的使用计数减 1 并检查这个使用计数。像析构函数中那样,如果这是指向 U_Ptr 对象的最后一个对象,就删除该对象,这会依次撤销 int 基础对象。将左操作数中的当前值减 1(可能撤销该对象)之后,再将指针从 rhs 复制到这个对象。赋值照常返回对这个对象的引用。

HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
    ++rhs.ptr->use; // increment use count on rhs first
    if (--ptr->use == 0)
        delete ptr; // if use count goes to 0 on this object,delete it

    ptr = rhs.ptr; // copy the U_Ptr object
    val = rhs.val; // copy the int member
    return *this;
}

这个赋值操作符在减少左操作数的使用计数之前使 rhs 的使用计数加 1,从而防止自身赋值。
如果左右操作数相同,赋值操作符的效果将是 U_Ptr 基础对象的使用计数加 1 之后立即减 1。

值型类

复制值型对象时,会得到一个不同的新副本。对副本所做的改变不会反映在原有对象上, 反之亦然。string类是值型类的一个例子。
要使指针成员表现得像一个值,复制 HasPtr 对象时必须复制指针所指向的对象:

复制构造函数不再复制指针,它将分配一个新的 int 对象,并初始化该对象以保存与被复制对象相同的值。每个对象都保存属于自己的 int 值的不同副本。因为每个对象保存自己的副本,所以析构函数将无条件删除指针。
赋值操作符不需要分配新对象,它只是必须记得给其指针所指向的对象赋新值,而不是给指针本身赋值。

//复制构造函数定义
HasPtr(const HasPtr &orig):
ptr(new int (*orig.ptr)), val(orig.val) { }
//赋值函数定义
HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
    *ptr = *rhs.ptr; // copy the value pointed to
    val = rhs.val; // copy the int
    return *this;
}

策略2:句柄类

C++ 中一个通用的技术是定义包装(cover)类或句柄类。句柄类存储和管理基类指针。指针所指对象的类型可以变化,它既可以指向基类类型对象又可以指向派生类型对象。用户通过句柄类访问继承层次的操作。因为句柄类使用指针执行操作,虚成员的行为将在运行时根据句柄实际绑定的对象的类型而变化。因此,句柄的用户可以获得动态行为但无须操心指针的管理。
包装了继承层次的句柄有两个重要的设计考虑因素:
* 像对任何保存指针的类一样,必须确定对复制控制做些什么。包装了集成层次的句柄通常表现得像一个智能指针或者像一个值。
* 句柄类决定句柄接口屏蔽还是不屏蔽继承层次,如果不屏蔽继承层次,用户必须了解和使用基本层次中的对象。
智能指针就是模拟指针动作的类。所有的智能指针都会重载 -> 和 * 操作符。

class Smart_Pointer
{
public:
    //default constructor: unbound handle
    Smart_Pointer():_p(0),_use(new std::size_t(1)){}
    //attaches a handle to a copy of the Base object
    Smart_Pointer(const Base&);

    //copy control members to manage the use count and pointers
    Smart_Pointer(const Smart_Pointer& i):
            _p(i._p),_use(i._use){++*use;}

    ~Smart_Pointer(){ decr_use();}
    Smart_Pointer& operator=(const Smart_Pointer&);

    //member access operators
    const Base *operator->() const
    {
        if(_p)
            return _p;
        else
            throw std::logic_error("unbound Base");
    }
    const Base &operator*() const
    {
        if(_p)
            return *p;
        else
            throw std::logic_error("unbound Base");
    }
private:
    Base *_p;
    std::size_t *_use;
    void decr_use()
    {
        if(--*use == 0)
        {
            delete _p;
            delete _use;
        }
    }
};

OpenCV的Ptr模板类

OpenCV中的智能指针Ptr模板类就是采用分离引用计数型的句柄类实现技术。
以OpenCV的人脸识别为例,实现了人脸识别中的三种算法: Eigenface、FisherFace和基于LBP特征的算法 。这三种算法也分别封装成三个类: Eigenfaces、Fisherfaces、LBPH 类,这三个类均派生自FaceRecognizer类,而 FaceRecognizer类则派生自 Algorithm 类。 FaceRecognizer类是一个抽象基类。
OpenCV就是采用一个泛型句柄类Ptr管理FaceRecognizer类的对象。

template<typename _Tp> class CV_EXPORTS Ptr
{
  public:
      //! empty constructor
      Ptr();
      //! take ownership of the pointer. The associated reference counter is allocated and set to 1
      Ptr(_Tp* _obj);
      //! calls release()
      ~Ptr();
     //! copy constructor. Copies the members and calls addref()
     Ptr(const Ptr& ptr);
     template<typename _Tp2> Ptr(const Ptr<_Tp2>& ptr);
     //! copy operator. Calls ptr.addref() and release() before copying the members
     Ptr& operator = (const Ptr& ptr);
     //! increments the reference counter
     void addref();
     //! decrements the reference counter. If it reaches 0, delete_obj() is called
     void release();
     //! deletes the object. Override if needed
     void delete_obj();
     //! returns true iff obj==NULL
     bool empty() const;
     //! cast pointer to another type
     template<typename _Tp2> Ptr<_Tp2> ptr();
     template<typename _Tp2> const Ptr<_Tp2> ptr() const;
     //! helper operators making "Ptr<T> ptr" use very similar to "T* ptr".
     _Tp* operator -> ();
     const _Tp* operator -> () const;
     operator _Tp* ();
     operator const _Tp*() const;
     _Tp* obj; //< the object pointer.
     int* refcount; //< the associated reference counter
};

当创建一个 FaceRecognizer的派生类 Eigenfaces 的对象时 , 我们把这个 Eigenfaces对象 放进 Ptr对象 内,就可以依赖句柄类 Ptr 确保 Eigenfaces对象自动被释放。

Ptr<FaceRecognizer> model = createEigenFaceRecognizer(num_components, threshold);

当利用 createEigenFaceRecognizer 动态创建一个 Eigenfaces 的对象后,立即把它放进 Ptr < FaceRecognizer > 中进行管理。获得资源后立即放进管理对象,管理对象运用析构函数确保资源被释放。

Ptr<FaceRecognizer> createEigenFaceRecognizer(int num_components, double threshold)
{
    return new Eigenfaces(num_components, threshold);
}

我们注意到在createEigenFaceRecognizer实现源码中,返回了动态地创建Eigenfaces对象,并且隐式的转换成Ptr。

相关评论

专题信息
    Visual C++是一个功能强大的可视化软件开发工具,是高等院校计算机及相关专业主要核心课程。 本教程对Visual C++ 的应用与开发进行了详细系统的介绍,内容主要包括:Visual C++程序的建立,菜单、工具栏和状态栏的创建,对话框和常用控件,窗口、文档与视图,图形绘制,数据库应用,多媒体技术等。 本教程以案例教学为主,各章节都附有大量的实例,并且操作步骤详细,有利于引导读者更好的消化、理解和实际应用本章节所学的知识内容,希望大家能多多支持中国站长网络学院!