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

opencv中的Ptr源码分析

猜你喜欢