Question

ooqp图书馆已在我的工作场所投入使用。目前有一名学生将其包裹起来，我想知道解决这个问题的最佳方法。以下是该程序使用的函数示例：

newQpGenSparse( double ** c, int nx,
    int ** irowQ, int nnzQ, int ** jcolQ, double ** dQ,
    double ** xlow, char ** ixlow,
    double ** xupp, char ** ixupp,
    int ** irowA, int nnzA, int ** jcolA, double ** dA,
    double ** b, int my,
    int ** irowC, int nnzC, int ** jcolC, double ** dC,
    double ** clow, int mz, char ** iclow,
    double ** cupp, char ** icupp,
    int * ierr );

http://pages.cs.wisc.edu/~swright/ooqp/ooqp-userguide.pdf

总权利？该库是用c++编写的，所以我正在寻找一种巧妙管理内存的方法。

在与这些函数接口时使用原始指针是必要的，但我希望可能更好的方法是使用std::shared_ptr然后将原始内存暴露给这些函数。这有一个明显的缺点，即shared_ptr的使用将被违反，尤其是在ooqp函数删除或编辑内存时。

有没有更好的方法来处理这个，然后只是非常小心新的和删除？

Answer 1

糟糕！显而易见的答案是重构库不要那样做。如果这是不可能的，你可以设计一个存储所有参数类型的类（希望有更多的描述性名称！）。

class QPGenSparseWrapper
{
    // Only store params if you want to manage their memory.
    double* Param1;

public:
    QPGenSparseWrapper(const double* param1, const int param2 /* , ... */, param16 = 22) :
        Param1(param1),
    {
        newQpGenSparse(&Param1, param2 /* , ... */, param16);
    }

    virtual ~QPGenSparseWrapper()
    {
        freeQpGenSparse(/* params */);

        // If no corresponding free, use smart pointers or manual delete.
    }

    void Run(/* more params?!? */)
    {
        // I hope you know what goes here.
    }
};

毋庸置疑，你应该为尽可能多的参数提供合理的默认设置，以免给未来的用户带来这样的心痛。

Answer 2

据我所知，库函数使用指针而不是引用。我不知道你有多少类似的功能，但如果有很多，那么这个想法可能会为你节省大量的编码。
这样您就可以使用std::shared_ptr并忘记freeQpGenSparse功能。

template<class T>
struct arg_type_to_wrapper_arg_type { typedef T result; };
template<class T>
struct arg_type_to_wrapper_arg_type<T*> { typedef T& result; };
template<class T>
struct arg_type_to_wrapper_arg_type<T**> { typedef std::shared_ptr<T>& result; }; // or unique_ptr

template<class T>
struct arg_value_setter_base {
    arg_type_to_wrapper_arg_type<T>& m_value;
    T m_new_value;
    T& get() { return m_new_value; }
};

template<class T>
struct arg_value_setter : public arg_value_setter_base<T> {
    arg_value_setter(arg_type_to_wrapper_arg_type<T>& value) : m_value(value), m_new_value(value) {}
    ~arg_value_setter() { }
};
template<class T>
struct arg_value_setter<T*> : public arg_value_setter_base<T*> {
    arg_value_setter(arg_type_to_wrapper_arg_type<T>& value) : m_value(value), m_new_value(null_ptr) {}
    ~arg_value_setter() { m_value = *m_new_value; }
};
template<class T>
struct arg_value_setter<T**> : public arg_value_setter_base<T**> {
    arg_value_setter(arg_type_to_wrapper_arg_type<T>& value) : m_value(value), m_new_value(null_ptr) {}
    ~arg_value_setter() { m_value.reset(*m_new_value); }
};

#define CREATE_WRAPPER_FOR_OOQP_ALLOC_FUNCTION(ret_type, function_name, arg_sequence) \
/* use boost preprocessor macros to get the following result. You just have to use BOOST_PP_SEQ_FOR_EACH_I 3 times. I will leave this job for you. */

void newQpGenSparseWrapper(
    arg_type_to_wrapper_arg_type<double **>::result arg_0, // std::shared_ptr<double>& arg_0
    arg_type_to_wrapper_arg_type<int>::result arg_1, 
    arg_type_to_wrapper_arg_type<int **>::result arg_2, // std::shared_ptr<int>& arg_2
    .....,
    arg_type_to_wrapper_arg_type<int *>::result arg_x // int& arg_x
    )
{
    arg_value_setter<double **> arg_setter_0(arg_0); 
    arg_value_setter<int> arg_setter_1(arg_1); 
    arg_value_setter<int **> arg_setter_2(arg_2); 
    .....,
    arg_value_setter<int *> arg_setter_x(arg_x);
    // TODO: you may want to avoid the assignment in case of the failure of the function to prevent shared_ptr from getting an invalid pointer 
    return newQpGenSparse(arg_setter_0.get(), arg_setter_1.get(), arg_setter_2.get(), .... , arg_setter_x.get());
}

现在，您只需为要包装的每个函数编写一行代码：

CREATE_WRAPPER_FOR_OOQP_ALLOC_FUNCTION(void, newQpGenSparse, (double **)(int)(int **) .... (int *) );

包装总库的最佳实践内存管理

2 个答案: