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

 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 };  

 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& Handle::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::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::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::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::operator->()const
73 {
74     if(ptr)
75         return ptr;
76     throw std::runtime_error("access through unbound Handle");    
77 }
78 
79 #endif

 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     };

 1 template 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 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 Ptr<_Tp2> ptr();
26     template const Ptr<_Tp2> ptr() const;
27 
28     //! helper operators making "Ptr 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; //
36     int* refcount; //
37 };

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 model = createEigenFaceRecognizer(num_components, threshold);

1 Ptr createEigenFaceRecognizer(int num_components, double threshold)
2 {
3     return new Eigenfaces(num_components, threshold);
4 }