我们知道在包含指针成员的类中，需要特别注意类的复制控制，因为复制指针时只复制指针中的地址，而不会复制指针指向的对象。这将导致当两个指针同时指向同一对象时，很可能一个指针删除了一对象，另一指针的用户还认为基础对象仍然存在，此时就出现了悬垂指针。
智能指针实现引用计数有两种经典策略：一是引入辅助类（包含引用计数型），二是使用句柄类（分离引用计数型）。
智能指针实现策略1：引用计数类
这个类U_Ptr的所有成员均为 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) //1 {}
HasPtr(const HasPtr& obj):_ptr(obj._ptr),_val(obj._val) //2 { ++_ptr->use; }
HasPtr& operator=(const HasPtr&); //3
~HasPtr() //4 { if(--_ptr->use == 0) delete _ptr; } private: U_Ptr* _ptr; int _val; };
1
接受一个指针和一个 int 值的 HasPtr 构造函数使用其指针形参ｐ创建一个新的 U_Ptr 对象。
HasPtr 构造函数执行完毕后，HasPtr 对象指向一个新分配的 U_Ptr 对象，该 U_Ptr 对象存储给定指针。
新 U_Ptr 中的使用计数为 1，表示只有一个 HasPtr 对象指向它。
2
复制构造函数从形参复制成员并增加使用计数的值。
复制构造函数执行完毕后，新创建对象与原有对象指向同一 U_Ptr 对象，该 U_Ptr 对象的使用计数加1。
3
赋值与引用计数
首先将右操作数中的使用计数加 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。
4
析构函数将检查 U_Ptr 基础对象的使用计数。如果使用计数为 0，则这是最后一个指向该 U_Ptr 对象的 HasPtr 对象，在这种情况下，HasPtr 析构函数删除其 U_Ptr 指针。
删除该指针将引起对 U_Ptr 析构函数的调用，U_Ptr 析构函数删除 int 基础对象。
值型类
复制值型对象时，会得到一个不同的新副本。对副本所做的改变不会反映在原有对象上， 反之亦然。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）类或句柄（handle）类。
句柄类存储和管理基类指针。指针所指对象的类型可以变化，它既可以指向基类类型对象又可以指向派生类型对象。用户通过句柄类访问继承层次的操作。
因为句柄类使用指针执行操作，虚成员的行为将在运行时根据句柄实际绑定的对象的类型而变化。因此，句柄的用户可以获得动态行为但无须操心指针的管理。
包装了继承层次的句柄有两个重要的设计考虑因素：
* 像对任何保存指针的类一样，必须确定对复制控制做些什么。包装了集成层次的句柄通常表现得像一个智能指针或者像一个值。
* 句柄类决定句柄接口屏蔽还是不屏蔽继承层次，如果不屏蔽继承层次，用户必须了解和使用基本层次中的对象。
智能指针就是模拟指针动作的类。所有的智能指针都会重载 -> 和 * 操作符。
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; } } };
Ptr<BaseColumnFilter> _columnFilter;，
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。
参考：