我可以为任何c++向量做一个C包装器吗?

Can I make one C wrapper for any C++ vector that could go in a Extern C

本文关键字：一个 包装 任何 c++ 向量 我可以      更新时间：2023-10-16

我需要一个C包装器，用于任何可以传递给期望某种特定类型向量的函数的c++向量。就像我下面的C包装器OpenCV的轻快"

void cv_BRISK_generateKernel(BRISK* self, vector_float* radiusList, 
vector_int* numberList, float dMax, float dMin, vector_int* indexChange) {
        self->generateKernel(*radiusList, *numberList, dMax, dMin, *indexChange);

}

vector_int*和vector_float*为typedef，如下

typedef vector<int> vector_int;
typedef vector<float> vector_float;

这些是我到目前为止的向量包装器，它们工作，但我想知道是否有一种方法可以为所有向量类型制作一个包装器。它必须放在Extern C中，所以它不能是模板。但是，而不是有下面的包装器，我想只做一个包装器，可以传递给一个函数期望vector_float* (typedef vector<float>)或vector_KeyPoint* (typedef vector<KeyPoint>)或vector_int* (typedef vector<int>)等。我知道模板类，但我不能在这里使用它们因为它必须放在extern C {}

中
vector_float* std_create_vectorf() {
    return new vector<float>;
}
vector_int* std_create_vector() {
    return new vector<int>;
}
vector_char* std_create_vectorc() {
    return new vector<char>;
}

这是我理想的包装，如果有人能帮我弄清楚如何做到这一点，我将不胜感激

vector_any_vec* std_create_vectorany() {
    return new vector<anyvector>;
}

如何使用运行时多态性将其封装在接口中?你牺牲了一点类型安全，但它应该达到你所需要的。

enum stored_type
{
    st_int,
    st_float,
    st_char
};
struct IGeneralVector
{
    virtual stored_type get_type() = 0;
    virtual void* get_data() = 0;
    virtual ~IGeneralVector();
};
class VectorFloatHolder : public IGeneralVector
{
    std::vector<float>* data;
public:
    VectorFloatHolder(std::vector<float>* in) : data(in)
    {}
    virtual stored_type get_type() override
    {
        return st_float;
    }
    virtual void* get_data() override
    {
        return reinterpret_cast<void *>(data);
    }
    virtual ~VectorFloatHolder()
    {
        delete data;
    }
};
IGeneralVector* std_create_vectorf()
{
    return new VectorFloatHolder(new std::vector<float>);
}

看了你的评论后，我对你想要达到的目标有了稍微更好的了解。但我不确定是否有可能做到你想要的，因为我不确定你有任何其他的实现约束。这里有另一种方法，这次使用类型擦除。

class ObjectHolder
{
    struct base_type
    {
        virtual ~base_type() {}
    };
    template<typename T>
    struct object_type : base_type
    {
        object_type(const T& t) : object(t) {}
        T object;
    };
    std::unique_ptr<base_type> data;
public:
    template<typename T>
    VectorHolder(T t) : data(new object_type<T>(t))
    {
    }
    template<typename T>
    T GetData()
    {
        object_type<T>* val = static_cast<object_type<T>*>(data.get());
        return val->object;
    }
};
template<typename T>
ObjectHolder* std_create_vector()
{
    return new VectorHolder(new std::vector<T>);
}

int main()
{
    ObjectHolder* vh = std_create_vector < std::vector<float>>();
    // then later on you can get back the original type via:
    std::vector<float>* fp = vh->GetData<std::vector<float>*>();
}
相关文章：