opencv中的Ptr源码分析

来研究一下opencv中的Ptr类，所谓的智能指针...

generic_type ref-counting pointer class for C/C++ objects /*! Smart pointer to dynamically allocated objects. This is template pointer-wrapping class that stores the associated reference counter along with the object pointer. The class is similar to std::smart_ptr<> from the recent addons to the C++ standard, but is shorter to write :) and self-contained (i.e. does add any dependency on the compiler or an external library). Basically, you can use "Ptr<MyObjectType> ptr" (or faster "const Ptr<MyObjectType>& ptr" for read-only access) everywhere instead of "MyObjectType* ptr", where MyObjectType is some C structure or a C++ class. To make it all work, you need to specialize Ptr<>::delete_obj(), like: \code template<> void Ptr<MyObjectType>::delete_obj() { call_destructor_func(obj); } \endcode \note{if MyObjectType is a C++ class with a destructor, you do not need to specialize delete_obj(), since the default implementation calls "delete obj;"} \note{Another good property of the class is that the operations on the reference counter are atomic, i.e. it is safe to use the class in multi-threaded applications} */ 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); //! 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; //! helper operators making "Ptr<T> ptr" use very similar to "T* ptr". _Tp* operator -> (); const _Tp* operator -> () const; operator _Tp* (); operator const _Tp*() const; protected: _Tp* obj; //< the object pointer. int* refcount; //< the associated reference counter };

所谓的智能指针，其实就是模板参数可以是任意的c++类，但考虑到对象在使用完毕的时候需要析构，因此要求特化delete_obj()函数。

接下来看源码

template<typename _Tp> inline Ptr<_Tp>::Ptr() : obj(0), refcount(0) {} template<typename _Tp> inline Ptr<_Tp>::Ptr(_Tp* _obj) : obj(_obj) { if(obj) { refcount = (int*)fastMalloc(sizeof(*refcount)); *refcount = 1; } else refcount = 0; }

obj显然是指向对象的指针，refcount是引用数，默认构造函数就构造了一个空对象，带参数的构造函数则需要动态分配内存，当然如果参数传入NULL的话，就与默认构造函数没有区别了...注意这里使用了fastMalloc这个函数，使用了对齐指针的技术...

void* fastMalloc( size_t size ) { uchar* udata = (uchar*)malloc(size + sizeof(void*) + CV_MALLOC_ALIGN); if(!udata) return OutOfMemoryError(size); uchar** adata = alignPtr((uchar**)udata + 1, CV_MALLOC_ALIGN); adata[-1] = udata; return adata; } void fastFree(void* ptr) { if(ptr) { uchar* udata = ((uchar**)ptr)[-1]; CV_DbgAssert(udata < (uchar*)ptr && ((uchar*)ptr - udata) <= (ptrdiff_t)(sizeof(void*)+CV_MALLOC_ALIGN)); free(udata); } }

其实内存多开了20字节的空间，其中4字节是用来存储这块空间的首地址的，用于释放空间时使用，还有16字节是用来调节地址，使地址达到16的倍数，CV_MALLOC_ALIGN在这里是16.

看一下alignPtr这个就是将地址向上调整至16的倍数，udata+1这里是指针加法，其实加的是sizeof(uchar**) 也就是4，这个4字节就是用来存首地址的，为什么要强转成uchar**,因为要访问这4个字节的内容，这个内容是个首地址，于是就是二级指针了。adata[-1]为什么这样？因为它先留出4字节之后在调整地址至16倍数，也就是实际存储数据的地址前还有至少4字节的空间，-1就是向前4字节，这个用来存首地址...

具体参考这篇博客http://blog.csdn.net/lming_08/article/details/26821963?utm_source=tuicool&utm_medium=referral

这个也值得学习

template<typename _Tp> inline void Ptr<_Tp>::addref() { if( refcount ) CV_XADD(refcount, 1); }

CV_XADD实际上是一个宏，对应了无锁化编程，类似后置自增运算，返回原值之后再增加，不过这个无锁化可以用于多线程编程，用户自己无需再维护锁了。

具体参考这篇博客：http://blog.csdn.net/hzhsan/article/details/25124901

template<typename _Tp> inline void Ptr<_Tp>::release() { if( refcount && CV_XADD(refcount, -1) == 1 ) { delete_obj(); fastFree(refcount); } refcount = 0; obj = 0; } template<typename _Tp> inline void Ptr<_Tp>::delete_obj() { if( obj ) delete obj; } template<typename _Tp> inline Ptr<_Tp>::~Ptr() { release(); }

注意这里的delete_obj是个泛化版本，对于无法delete的，需要实现一个特化版本。

其他构造函数

template<typename _Tp> inline Ptr<_Tp>::Ptr(const Ptr<_Tp>& ptr) { obj = ptr.obj; refcount = ptr.refcount; addref(); } template<typename _Tp> inline Ptr<_Tp>& Ptr<_Tp>::operator = (const Ptr<_Tp>& ptr) { int* _refcount = ptr.refcount; if( _refcount ) CV_XADD(_refcount, 1); release(); obj = ptr.obj; refcount = _refcount; return *this; }

注意拷贝构造函数，参数对应的对象无需释放，所以引用数加1，而赋值构造函数则需要先释放掉参数对应的对象，这是区别。

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

关于->的重载非常奇怪，竟然无参数的，返回值必须是object*，但是->貌似又被object*共用去访问成员了...

具体参考这篇博客：http://blog.csdn.net/zhuxiufenghust/article/details/5708167

 

到此为止，我们大概知道如何自己实现一个智能指针类了...

原文：https://blog.csdn.net/eric_e/article/details/79375602