由C++的泛型句柄类思考OpenCV的Ptr模板类

OpenCV（计算机视觉库）2.4.4版本已经发布了，OpenCV发展到现在，由最初的C接口变成现在的C++接口，让开发者写程序越来越简单，接口越来越合理，也不用担心内存释放问题。但要理解内部的一些实现机制，还真要费点功夫，这对开发者的C++基础要求越来越高。本文就是笔者在做项目过程中的一点感悟，由C++泛型句柄类思考OpenCV的Ptr模板类的实现。

1、C++泛型句柄类                                                                                                                                                                                                                                                                        

我们知道在包含指针成员的类中，需要特别注意类的复制控制，因为复制指针时只复制指针中的地址，而不会复制指针指向的对象。这将导致当两个指针同时指向同一对象时，很可能一个指针删除了一对象，另一指针的用户还认为基础对象仍然存在，此时就出现了悬垂指针。

当类中有指针成员时，一般有两种方式来管理指针成员： 一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更好的方式是 使用智能指针，从而实现指针指向的对象的共享。（可参看《C++ Primer第四版》P419）

 

智能指针(smart pointer)的一种通用实现技术是使用 引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。

每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的父本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。

 

智能指针实现引用计数有两种经典策略：一是引入 辅助类（包含引用计数型），二是使用 句柄类（分离引用计数型）。

• 辅助类的解决方案是，定义一个单独的具体类来封装指针和相应的引用计数。可参考我之前写的一个博客：http://www.cnblogs.com/liu-jun/archive/2013/03/01/2939396.html

辅助类实现智能指针代码如下，参考《C++沉思录》，利用UPoint类作为辅助类封装了指针Point*和引用计数，从而代替指针Point*。这个技术的主要思想是当多个Handle类的对象在堆上共享同一个Point*指向的内存区时，我们在这个内存区上多分配一点空间存放引用计数，那么我们就可以知道有多少个Handle类的对象在共享Point*指向的内存区，当引用计数为0时，我们就可以很放心的释放掉这块内存区，而不会出现悬垂指针了。

 1 //辅助类UPoint

 2 class UPoint{  

 3     private:  

 4         friend class Handle;  

 5         int u;  

 6         Point p;  

 7         UPoint(const Point& pp):u(1),p(pp)  

 8         {  

 9               

10         }  

11         UPoint(int xx,int yy):p(xx,yy),u(1)  

12         {  

13           

14         }  

15         UPoint():u(1)  

16         {  

17           

18         }  

19 };  

20   

21 class Handle{  

22     public:  

23         Handle():up(new UPoint)  

24         {  

25           

26         }  

27         Handle(int x,int y):up(new UPoint(x,y))  

28         {  

29           

30         }  

31         Handle(const Point& up):up(new UPoint(up))

32         {  

33           

34         }  

35        //复制构造函数

36         Handle(const Handle& other):up(other.up)  

37         {  

38             ++up->u;  

39         } 

40         //赋值操作符

41         Handle& operator=(const Handle& other)  

42         {  

43             ++other.up->u;  

44             if(--up->u==0){  

45                 delete up;  

46             }  

47             up = other.up;  

48             return *this;  

49         }  

50         ~Handle()  

51         {  

52             if(--up->u == 0){  

53                 delete up;  

54             }  

55         }               

56     private:  

57             UPoint *up;  

58 };  

基于辅助类的智能指针实现方式需要创建一个依赖于Point类的新类，这样做对于特定的类而言是很好，但却让我们很难将句柄绑定到Point类派生的新类对象上。因此，就有了分离引用计数型的句柄类实现了。可参看《C++ 沉思录》P69页，OpenCV中的智能指针模板类Ptr就是基于这种计数实现。
下面是采用模板的方式实现的一个泛型句柄类（分离引用计数型），参考《C++ Primer第四版》P561。从下面可以看出辅助类消失了，在这个句柄类中，我们用指向类型T的指针（共享对象，类似于上面的Point类型）和指向一个int的指针表示引用计数。使用T*很重要，因为正是T*使我们不仅能够将一个Handle绑定到一个T类型的对象，还能将其绑定到一个继承自T的类的对象。

这个类模板的数据成员有两个：指向某个实际需要管理的类型的数据的指针以及它的引用计数。它定义了复制构造函数、赋值操作符以及解引、成员访问操作符。其中解引操作符返回的是实际需要管理的数据，而箭头操作符返回的是这个指针。这两个操作符使得我们操作Handle<T>的对象就跟操作T的对象一样。

 1 #ifndef HANDLE_H

 2 #define HANDLE_H

 3 

 4 template <class T> class Handle

 5 {

 6 public:

 7     //构造函数：空指针

 8     Handle(T *p = 0):ptr(p),use(new size_t(1)){}

 9     //重载解引和箭头操作符

10     T& operator*();

11     T* operator->();

12     const T& operator*()const;

13     const T* operator->()const;

14     //复制构造函数

15     Handle(const Handle& h):ptr(h.ptr),use(h.use){++*use;}

16     //重载赋值操作符

17     Handle& operator=(const Handle&);

18     //析构函数

19     ~Handle(){rem_ref();};

20 private:

21     //共享的对象

22     T *ptr;

23     //引用计数

24     size_t *use;

25     //删除指针的具体函数

26     void rem_ref()

27     {

28         if(--*use == 0)

29         {

30             delete ptr;

31             delete use;

32         }

33     }

34 };

35 

36 template<class T>

37 inline Handle<T>& Handle<T>::operator=(const Handle &rhs)

38 {

39     //右操作数引用计数+1

40     ++*rhs.use;

41     //删除左操作数

42     rem_ref();

43     //具体对象的赋值

44     ptr = rhs.ptr;

45     use = rhs.use;

46     return *this;

47 }

48 

49 template <class T> inline T& Handle<T>::operator*()

50 {

51     if(ptr)

52         return *ptr;

53     //空指针时抛出异常

54     throw std::runtime_error("dereference of unbound Handle");

55 }

56 

57 template <class T> inline T* Handle<T>::operator->()

58 {

59     if(ptr)

60         return ptr;

61     //空指针时抛出异常

62     throw std::runtime_error("access through unbound Handle");

63 }

64 

65 template <class T> inline const T& Handle<T>::operator*()const

66 {

67     if(ptr)

68         return *ptr;

69     throw std::runtime_error("dereference of unbound Handle");

70 }

71 

72 template <class T> inline const T* Handle<T>::operator->()const

73 {

74     if(ptr)

75         return ptr;

76     throw std::runtime_error("access through unbound Handle");    

77 }

78 

79 #endif

2、OpenCV中的智能指针模板类Ptr                                                                                                                                                                                           

以上了解了C++中的泛型句柄类实现后，我们来看看OpenCV中怎么利用泛型句柄类来管理OpenCV中的资源。

在OpenCV2.4.2后，添加了FaceRecognizer这个人脸识别类。其中实现了人脸识别中的三种算法：Eigenface、FisherFace和基于LBP特征的算法。这三种算法也分别封装成三个类：Eigenfaces、Fisherfaces、LBPH类，这三个类均派生自FaceRecognizer类，而FaceRecognizer类则派生自Algorithm类。FaceRecognizer类是一个抽象基类，它的头文件在contrib.hpp中（以OpenCV2.4.4为例），下面是它的头文件。

 1  class CV_EXPORTS_W FaceRecognizer : public Algorithm

 2     {

 3     public:

 4         //! virtual destructor

 5         virtual ~FaceRecognizer() {}

 6 

 7         // Trains a FaceRecognizer.

 8         CV_WRAP virtual void train(InputArrayOfArrays src, InputArray labels) = 0;

 9 

10         // Updates a FaceRecognizer.

11         CV_WRAP void update(InputArrayOfArrays src, InputArray labels);

12 

13         // Gets a prediction from a FaceRecognizer.

14         virtual int predict(InputArray src) const = 0;

15 

16         // Predicts the label and confidence for a given sample.

17         CV_WRAP virtual void predict(InputArray src, CV_OUT int &label, CV_OUT double &confidence) const = 0;

18 

19         // Serializes this object to a given filename.

20         CV_WRAP virtual void save(const string& filename) const;

21 

22         // Deserializes this object from a given filename.

23         CV_WRAP virtual void load(const string& filename);

24 

25         // Serializes this object to a given cv::FileStorage.

26         virtual void save(FileStorage& fs) const = 0;

27 

28         // Deserializes this object from a given cv::FileStorage.

29         virtual void load(const FileStorage& fs) = 0;

30 

31     };

以人脸识别FaceRecognizer类为例，OpenCV就是采用一个泛型句柄类Ptr管理FaceRecognizer类的对象。先来看看OpenCV中的Ptr类是怎么实现的。OpenCV中的Ptr模板类头文件在core.hpp（以OpenCV2.4.4为例），源文件则在operations.hpp（以OpenCV2.4.4为例）。

Ptr模板类头文件：

 1 template<typename _Tp> class CV_EXPORTS Ptr

 2 {

 3 public:

 4     //! empty constructor

 5     Ptr();

 6     //! take ownership of the pointer. The associated reference counter is allocated and set to 1

 7     Ptr(_Tp* _obj);

 8     //! calls release()

 9     ~Ptr();

10     //! copy constructor. Copies the members and calls addref()

11     Ptr(const Ptr& ptr);

12     template<typename _Tp2> Ptr(const Ptr<_Tp2>& ptr);

13     //! copy operator. Calls ptr.addref() and release() before copying the members

14     Ptr& operator = (const Ptr& ptr);

15     //! increments the reference counter

16     void addref();

17     //! decrements the reference counter. If it reaches 0, delete_obj() is called

18     void release();

19     //! deletes the object. Override if needed

20     void delete_obj();

21     //! returns true iff obj==NULL

22     bool empty() const;

23 

24     //! cast pointer to another type

25     template<typename _Tp2> Ptr<_Tp2> ptr();

26     template<typename _Tp2> const Ptr<_Tp2> ptr() const;

27 

28     //! helper operators making "Ptr<T> ptr" use very similar to "T* ptr".

29     _Tp* operator -> ();

30     const _Tp* operator -> () const;

31 

32     operator _Tp* ();

33     operator const _Tp*() const;

34 

35     _Tp* obj; //< the object pointer.

36     int* refcount; //< the associated reference counter

37 };

Ptr模板类源文件：

View Code

  1 /////////////////////////////////// Ptr ////////////////////////////////////////

  2 

  3 template<typename _Tp> inline Ptr<_Tp>::Ptr() : obj(0), refcount(0) {}

  4 template<typename _Tp> inline Ptr<_Tp>::Ptr(_Tp* _obj) : obj(_obj)

  5 {

  6     if(obj)

  7     {

  8         refcount = (int*)fastMalloc(sizeof(*refcount));

  9         *refcount = 1;

 10     }

 11     else

 12         refcount = 0;

 13 }

 14 

 15 template<typename _Tp> inline void Ptr<_Tp>::addref()

 16 { if( refcount ) CV_XADD(refcount, 1); }

 17 

 18 template<typename _Tp> inline void Ptr<_Tp>::release()

 19 {

 20     if( refcount && CV_XADD(refcount, -1) == 1 )

 21     {

 22         delete_obj();

 23         fastFree(refcount);

 24     }

 25     refcount = 0;

 26     obj = 0;

 27 }

 28 

 29 template<typename _Tp> inline void Ptr<_Tp>::delete_obj()

 30 {

 31     if( obj ) delete obj;

 32 }

 33 

 34 template<typename _Tp> inline Ptr<_Tp>::~Ptr() { release(); }

 35 

 36 template<typename _Tp> inline Ptr<_Tp>::Ptr(const Ptr<_Tp>& _ptr)

 37 {

 38     obj = _ptr.obj;

 39     refcount = _ptr.refcount;

 40     addref();

 41 }

 42 

 43 template<typename _Tp> inline Ptr<_Tp>& Ptr<_Tp>::operator = (const Ptr<_Tp>& _ptr)

 44 {

 45     int* _refcount = _ptr.refcount;

 46     if( _refcount )

 47         CV_XADD(_refcount, 1);

 48     release();

 49     obj = _ptr.obj;

 50     refcount = _refcount;

 51     return *this;

 52 }

 53 

 54 template<typename _Tp> inline _Tp* Ptr<_Tp>::operator -> () { return obj; }

 55 template<typename _Tp> inline const _Tp* Ptr<_Tp>::operator -> () const { return obj; }

 56 

 57 template<typename _Tp> inline Ptr<_Tp>::operator _Tp* () { return obj; }

 58 template<typename _Tp> inline Ptr<_Tp>::operator const _Tp*() const { return obj; }

 59 

 60 template<typename _Tp> inline bool Ptr<_Tp>::empty() const { return obj == 0; }

 61 

 62 template<typename _Tp> template<typename _Tp2> Ptr<_Tp>::Ptr(const Ptr<_Tp2>& p)

 63     : obj(0), refcount(0)

 64 {

 65     if (p.empty())

 66         return;

 67 

 68     _Tp* p_casted = dynamic_cast<_Tp*>(p.obj);

 69     if (!p_casted)

 70         return;

 71 

 72     obj = p_casted;

 73     refcount = p.refcount;

 74     addref();

 75 }

 76 

 77 template<typename _Tp> template<typename _Tp2> inline Ptr<_Tp2> Ptr<_Tp>::ptr()

 78 {

 79     Ptr<_Tp2> p;

 80     if( !obj )

 81         return p;

 82 

 83     _Tp2* obj_casted = dynamic_cast<_Tp2*>(obj);

 84     if (!obj_casted)

 85         return p;

 86 

 87     if( refcount )

 88         CV_XADD(refcount, 1);

 89 

 90     p.obj = obj_casted;

 91     p.refcount = refcount;

 92     return p;

 93 }

 94 

 95 template<typename _Tp> template<typename _Tp2> inline const Ptr<_Tp2> Ptr<_Tp>::ptr() const

 96 {

 97     Ptr<_Tp2> p;

 98     if( !obj )

 99         return p;

100 

101     _Tp2* obj_casted = dynamic_cast<_Tp2*>(obj);

102     if (!obj_casted)

103         return p;

104 

105     if( refcount )

106         CV_XADD(refcount, 1);

107 

108     p.obj = obj_casted;

109     p.refcount = refcount;

110     return p;

111 }

112 

113 //// specializied implementations of Ptr::delete_obj() for classic OpenCV types

114 

115 template<> CV_EXPORTS void Ptr<CvMat>::delete_obj();

116 template<> CV_EXPORTS void Ptr<IplImage>::delete_obj();

117 template<> CV_EXPORTS void Ptr<CvMatND>::delete_obj();

118 template<> CV_EXPORTS void Ptr<CvSparseMat>::delete_obj();

119 template<> CV_EXPORTS void Ptr<CvMemStorage>::delete_obj();

120 template<> CV_EXPORTS void Ptr<CvFileStorage>::delete_obj();

可以看出，OpenCV中的智能指针Ptr模板类就是采用分离引用计数型的句柄类实现技术。

下面来看看在OpenCV中怎么应用Ptr模板类来管理OpenCV的资源对象，以人脸识别FaceRecognizer类为例。

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

 

1 // Let's say we want to keep 10 Eigenfaces and have a threshold value of 10.0

2 int num_components = 10;

3 double threshold = 10.0;

4 // Then if you want to have a cv::FaceRecognizer with a confidence threshold,

5 // create the concrete implementation with the appropiate parameters:

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

第6行的createEigenFaceRecognizer函数的源码在facerec.cpp中，如下所示。

1 Ptr<FaceRecognizer> createEigenFaceRecognizer(int num_components, double threshold)

2 {

3     return new Eigenfaces(num_components, threshold);

4 }

 我们来分析下上面两段代码，其中Ptr<FaceRecognizer> model = createEigenFaceRecognizer(num_components, threshold);
当利用createEigenFaceRecognizer动态创建一个Eigenfaces的对象后，立即把它放进Ptr<FaceRecognizer>中进行管理。这和《Effective C++:55 Specific Ways to Improve Your Programs and Designe 3rd Edition》中的条款13不谋而合，即获得资源后立即放进管理对象，管理对象运用析构函数确保资源被释放。

我们注意到在createEigenFaceRecognizer实现源码中，返回了动态创建地Eigenfaces对象，并且隐式的转换成Ptr<FaceRecognizer>。（注意：这里的隐式转换依赖于Ptr<FaceRecognizer>的构造函数，相关知识可参考《C++ Primer第四版》P394页）

这个返回智能指针的设计非常好，在《Effective C++:55 Specific Ways to Improve Your Programs and Designe 3rd Edition》中条款18中提到：任何接口如果要求客户必须记得某些事情，就有着“不正确使用”的倾向，因为客户可能会忘记做那件事。

这里也一样，万一客户（即使用OpenCV库的开发者）忘记使用智能指针Ptr类怎么办？因此，许多时候，较佳接口的设计原则采用先发制人，这里就是令createEigenFaceRecognizer返回一个智能指针Ptr<FaceRecognizer>。

这样，开发者就必须采用这样的方式来创建Eigenfaces对象：Ptr<FaceRecognizer> model = createEigenFaceRecognizer(num_components, threshold);