c++ - 我可以为任何可以进入 Extern C 的 C++ vector 制作一个 C 包装器吗

Question

我需要一个用于任何 C++ vector 的 C 包装器，该 vector 可以传递给需要某种特定类型 vector 的函数。就像我下面的 OpenCV BRISK 的 C 包装器一样”

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;

这些是我迄今为止拥有的 vector 包装器，它们可以工作，但我想知道是否有一种方法可以为所有 vector 类型制作一个包装器。它必须放在 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>;
}

Answer 1

如何使用运行时多态性将其包装在接口(interface)中？您牺牲了一点类型安全性，但它应该可以实现您所需要的。

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>*>();
}