带有用 C 编写的库的智能指针

Question

我将 C++ 与 OpenCV 库一起使用，这是一个图像处理库，尽管与这个问题无关。 目前我需要做出一个设计决定。

OpenCV 作为一个 C 库，其数据结构（例如 CvMat）被声明为结构体。 要创建它们，您可以使用 cvCreateMat 等函数，而要释放它们，您可以使用 cvReleaseMat 等函数。 作为一名 C++ 程序员，我创建了一个特殊的 cv_scoped 类，当它超出范围时，它会自动调用 cvReleaseMat（如 boost::scoped_ptr）。

我现在意识到，我希望在某些情况下也可以使用 auto_ptr 和 shared_ptr 。 我只是觉得为自己的 cv_auto_ptr 和 cv_shared_ptr 类编写代码是一个坏主意，更不用说浪费时间了。 所以我一直在寻找解决方案，并提出了三种可能性。

首先，我可以使用我已经创建的 cv_scoped 类。 我将其重命名为 cv_ptr，然后使用智能指针，如下所示：std::auto_ptr。 但令人烦恼的是，我总是必须取消引用两次：

std::auto_ptr<cv_ptr> matrix(cv_ptr(cvCreateMat(320, 240, CV_32FC3)));
cvPow(matrix.get()->get()); // one get for the auto_ptr, one for the cv_ptr

我知道看起来我可以声明隐式转换，但实际上我不能 - 大多数 OpenCV 函数都有参数 void* - 所以没有隐式转换会被称为。 我真的很想要一种不需要进行双重解引用的方法。

第二，我可以以某种方式覆盖operator delete。 我不想覆盖全局运算符删除，因为我只想将其应用于 CvMat （和其他一些）类型。 但是，我无法更改库，因此无法将 operator delete 添加到 CvMat 结构中。 所以我不知道这将如何运作。

第三，我可以重写自己的 auto_ptr、scoped_ptr 和 shared_ptr。 它们的班级规模不大，所以不会太困难，但我只是觉得这是一个糟糕的设计。 如果我这样做，我可能会做这样的事情：

class cv_auto_ptr {
public:
  cv_auto_ptr();
  ~cv_auto_ptr();

  // each method would just be a proxy for the smart pointer
  CvMat* get() { return this->matrix_.get()->get(); }
  // all the other operators/methods in auto_ptr would be the same, you get the idea

private:
  auto_ptr<cv_ptr> matrix_; // cv_ptr deletes CvMat properly
}

如果我遇到这种情况，你会怎么做？ 请帮我解决这个问题。

Answer 1

您可以考虑的一种方法是利用 std::tr1::shared_ptr 具有提供自定义删除器的功能。 我对 OpenCV 不熟悉，所以我从你所写的内容中推断。

struct CvMatDeleter
{
    void operator( CvMat* p ) { cvReleaseMat( p ) ; }
};

void test()
{
    std::tr1::shared_ptr< CvMat > pMat( cvCreateMat(320, 240, CV_32FC3), CvMatDeleter() );
    // . . .
}

因为删除器存储在共享指针中，所以您可以照常使用它，当最终需要删除共享原始指针时，将根据需要调用cvReleaseMat。 请注意，auto_ptr 和 scoped_ptr 是更轻量级的类，因此不具备自定义删除器的功能，但如果您准备好承受较小的开销，那么 shared_ptr< /code> 可以用来代替它们。

Answer 2

auto_ptr 实际上是为 C++ 类上的 RAII 设计的，具有构造/析构函数，您在这里将它们的用途推向它们可能不应该用于（但可以）的用途。

无论如何，您是否希望能够像普通堆栈变量一样使用 C++ 对象，而无需每次都动态分配？

问题的标准解决方案是创建一个带有构造函数/析构函数的包装器。
但要使其可供 C 函数使用，只需添加一个内部强制转换运算符，以便在传递给 C 函数时它会自动将自身神奇地转换回 C 对象

编写一个包装类。

class Mat
{
    CvMat* impl;
    public:
        Mat(/* Constructor  Arguments */)
        {
            impl = cvCreateMat(/* BLAH */);
        }
        ~Mat()
        {
            cvReleaseMat(impl);
        }
        operator CvMat*()
        {   // Cast opertator. Convert your C++ wrapper object into C object
            // when you use it with all those C functions that come with the
            // library.

            return impl;
        }
};

void Plop(CvMat* x)
{   // Some C function dealing with CvMat
}

int main()
{                            // Don't need to dynamically allocate
    Mat                  m;  // Just create on the stack.
    Plop(m);                 // Call Plop directly

    std::auto_ptr<Mat>   mP(new Mat);
    Plop(*mP);
}

Answer 3

如果您关心的只是异常安全，请在每次使用矩阵时执行此操作：

void f() {
    try {
        CvMat* mat = cvCreateMat(320, 240, CV_32FC3));
        // ...
    } catch(...) {
        cvReleaseMat(mat);
        throw;
    }
    cvReleaseMat(mat);
}

另一方面，如果您想要一个合理解决方案，请加倍努力并编写完整的包装器。

namespace cv {

class Mat {
public:
    enum Type { /* ... */ };
    Mat(int w, int h, Type type) {
        impl = cvCreateMat(w, h, intFromType(type));
    }

    ~Mat() {
        cvReleaseMat(impl);
    }

    void pow() { // wrap all operations
        cvPow(impl);
    }

private:
    CvMat* impl;
};

}

走中间路线，使用通用智能指针和“cv_ptrs”的大杂烩，听起来像是令人头痛和不必要的并发症的良方。