Question

我正在为C-API编写包装器。

（i）令capi_array_data capi_get_array(void)是包含在此库中的函数，该函数返回一个结构，该结构包含有关由该API管理的堆分配数组的元数据。看起来像struct capi_get_array { size_t length; int* arr };（为简单起见，使用int）

（ii）这样的数组可以由用户使用malloc，new，std::vector等手动创建。然后必须在void capi_register_array(int*)中注册。 / p>

我想创建一个包装器类，将其命名为MyArrayWrapper，使用STL容器的解剖结构管理此类数组，并支持operator[]，begin，back，在（i）中，该包装器将不拥有数据，但在（ii）中，它将拥有数据。我现在的问题是，是否应该

（a）具有一个单一的类，可以使用std::initializer_list（或该主题的可变参数模板）或API返回的int*来构造该类；

（b）具有单独的类，名称分别为MyArrayWrapperRef和MyArrayWrapper，第一个处理（i）和第二个处理（ii）；

（c）的（i）最佳语法为MyArrayWrapper&，而（ii）的最佳语法为MyArrayWrapper；可以做到吗？

使用（a）可能会引起混乱，因为一个班级要做两件事，这打破了单一责任原则。回答“复制构造函数是否进行浅层复制？”之类的问题。不会很明显，需要进一步的文档。

（b）似乎是一个不错的选择，但是现在有多种情况：MyArrayWrapper，MyArrayWrapper&，MyArrayWrapperRef，MyArrayWrapperRef&。它们有何不同？ const参考呢？这甚至可能需要另一个类MyArrayWrapperConstRef，并再次导致混乱。

（c）是最佳的，对于其他类来说似乎很自然，但是我不知道使它起作用的方法。我可以包装capi_get_array并返回MyArrayWrapperRef，但是我必须将引用源保存在某个地方，对吧？

Answer 1

随着（a）可能会引起混乱，因为一个班级要做两件事，这打破了单一责任原则。

您还可以反过来查看：包装器的唯一职责是隐藏真实所有权以及谁来清理内容。

让我们说你有这个：

struct arr_data {
    int* a;
    unsigned size;
};
arr_data get_arr(){
    arr_data ret;
    ret.size = 5;
    ret.a = new int[ret.size];
    return ret;
}
void reg_arr(arr_data x){
    static arr_data store = x;
}

然后一个简单的包装器可能看起来像这样：

struct wrapper {
    std::shared_ptr<arr_data> data;
    // implement container-like interface
};

wrapper make_non_owning_wrapper() { 
    auto res = new arr_data();
    *res = get_arr();
    return { std::shared_ptr<arr_data>(res,[](arr_data* x){
            std::cout << "delete x only\n";
            delete x;
    }) };
}

wrapper make_owning_wrapper() {
    auto res = new arr_data();
    res->size = 5;
    res->a = new int[res->size];
    return { std::shared_ptr<arr_data>(res,[](arr_data* x){
        std::cout << "delete both\n";
        delete[] x->a;
        delete x;
    })};
}

int main(){
    auto v = make_owning_wrapper();
    auto w = make_non_owning_wrapper();
    auto z = v;
}

使用共享指针，您可以选择a）清理操作和b）复制wrapper时发生的事情而不会引起很大的混乱;）。

自定义参考类型

1 个答案: