释放 cv::Mat 而不释放内存

Question

我将 Mat 数据（不是 cv::Mat 对象）传递给函数，并使该函数成为该数据的新所有者。但是，我需要一种方法来释放原始对象，而不释放它指向的数据缓冲区。

我知道这种情况会发生在从外部数据创建的 cv::Mat 上，我只需要将此功能用于一般的 cv::Mat 即可。

有办法做到这一点吗？

Answer 1

您可以使用addref()方法，但是您将出现内存泄漏。

实际上，将数据与 Mat 分离并不是一个好主意：

• 它不是为此而设计的；
• 你不能保证从一般的cv::Mat获得的指针指向分配的内存块的开头；
• 您很可能无法自己释放该内存，因为 cv::Mat 可能使用自己的内存分配例程（有很多原因需要这样做，例如对齐）。
• 即使你找到了解决数据指针所有问题的方法，你仍然无法避免Mat引用计数器的内存泄漏。

因此，Mat 只能保证支持两种方式：

• 提供有关 Mat 创建的指针；
• 将数据复制到缓冲区。

任何其他方式即使在当前版本中有效，也可能在未来版本中被破坏。

Answer 2

您可以使用 lambda 捕获 Mat，并且可以使用该 lambda 作为删除器来延长其生命周期并将其绑定到 shared_ptr/unique_ptr。

Mat matrix;
...
std::shared_ptr<uchar*> ptr(matrix.ptr(),[matrix](uchar*){});

当您不想在公共接口上使用 opencv，并且无法提供有关 Mat 创建的指针或不想将数据复制到缓冲区时，它非常有用。

Answer 3

使用 release()

Ptr

http://opencv.willowgarage.com /documentation/cpp/basic_structs.html

智能引用计数指针的模板

template<typename _Tp> class Ptr
{
public:
    // default constructor
    Ptr();
    // constructor that wraps the object pointer
    Ptr(_Tp* _obj);
    // destructor: calls release()
    ~Ptr();
    // copy constructor; increments ptr's reference counter
    Ptr(const Ptr& ptr);
    // assignment operator; decrements own reference counter
    // (with release()) and increments ptr's reference counter
    Ptr& operator = (const Ptr& ptr);
    // increments reference counter
    void addref();
    // decrements reference counter; when it becomes 0,
    // delete_obj() is called
    void release();
    // user-specified custom object deletion operation.
    // by default, "delete obj;" is called
    void delete_obj();
    // returns true if obj == 0;
    bool empty() const;

    // provide access to the object fields and methods
    _Tp* operator -> ();
    const _Tp* operator -> () const;

    // return the underlying object pointer;
    // thanks to the methods, the Ptr<_Tp> can be
    // used instead of _Tp*
    operator _Tp* ();
    operator const _Tp*() const;
protected:
    // the encapsulated object pointer
    _Tp* obj;
    // the associated reference counter
    int* refcount;
};

类 Ptr<_Tp> 类是一个包装相应类型指针的模板类。它类似于shared_ptr，它是Boost库的一部分（http: //www.boost.org/doc/libs/1_40_0/libs/smart_ptr/shared_ptr.htm ）以及一部分C++0x 标准。

通过使用该类，您可以获得以下功能：

default constructor, copy constructor and assignment operator for an arbitrary C++ class or a C structure. For some objects, like files, windows, mutexes, sockets etc, copy constructor or assignment operator are difficult to define. For some other objects, like complex classifiers in OpenCV, copy constructors are absent and not easy to implement. Finally, some of complex OpenCV and your own data structures may have been written in C. However, copy constructors and default constructors can simplify programming a lot; besides, they are often required (e.g. by STL containers). By wrapping a pointer to such a complex object TObj to Ptr<TObj> you will automatically get all of the necessary constructors and the assignment operator.
all the above-mentioned operations running very fast, regardless of the data size, i.e. as “O(1)” operations. Indeed, while some structures, like std::vector provide a copy constructor and an assignment operator, the operations may take considerable time if the data structures are big. But if the structures are put into Ptr<> , the overhead becomes small and independent of the data size.
automatic destruction, even for C structures. See the example below with FILE* .
heterogeneous collections of objects. The standard STL and most other C++ and OpenCV containers can only store objects of the same type and the same size. The classical solution to store objects of different types in the same container is to store pointers to the base class base_class_t* instead, but when you loose the automatic memory management. Again, by using Ptr<base_class_t>() instead of the raw pointers, you can solve the problem.

Ptr 类将包装对象视为黑盒，引用计数器单独分配和管理。指针类需要了解该对象的唯一事情是如何释放它。这些知识被封装在 Ptr::delete_obj() 方法中，当引用计数器变为 0 时调用该方法。如果对象是 C++ 类实例，则不需要额外的编码，因为该方法的默认实现调用 delete obj； 。但是，如果以不同方式释放对象，则应创建专门的方法。例如，如果你想包装 FILE ，delete_obj 可以实现如下：

template<>内联 void Ptr::delete_obj()
{
fclose(obj); // 之后不需要清除指针，
// 这是在外部完成的。
}
...

// 现在使用它：
Ptr f(fopen("myfile.txt", "r"));
if(f.empty())
扔 ...;
fprintf(f, ....);
...
// 文件将被 Ptr 析构函数自动关闭。

注意：引用递增/递减操作是作为原子操作实现的，因此在多线程应用程序中使用这些类通常是安全的。对于在引用计数器上运行的 Mat 和其他 C++ OpenCV 类也是如此。