Question

我需要维护一个vector（int），vector（char）和vector（float）的列表。这可能吗？

Answer 1

我不确定我理解你的问题。

boost::variant您要找的是什么？它允许您将不同类型的元素存储在一个容器中。

一些示例代码（未经测试）：

typedef boost::variant <
  std::vector<int>, 
  std::vector<char>, 
  std::vector<float>
> VectorOfIntCharOrFloat;
std::list<VectorOfIntCharOrFloat> vec;

然后迭代它/访问元素：

std::list<VectorOfIntCharOrFloat>::iterator itr = vec.begin();
while(itr != vec.end()) {
  if(std::vector<int> * i = boost::get<std::vector<int> >(itr)) {
    std::cout << "int vector"<< std::endl;
  } else if(std::vector<float> * f = boost::get<std::vector<float> >(itr)) {
    std::cout << "float vector" << std::endl;
  } else if(std::vector<char> * c = boost::get<std::vector<char> >(itr)){
    std::cout << "char vector" << std::endl;
  }
  ++itr;
}

Answer 2

您可以尝试以下方法：

    #include <iostream>
    #include <vector>

    struct WrapperBase
    {
        // WrapperBase needs to be polymorphic for dynamic_cast
        virtual ~WrapperBase()
        {  }
    };

    template <typename T>
    struct VectorWrapper : public WrapperBase
    {
        std::vector<T> vector;
    };

    int main()
    {
        std::vector<WrapperBase*> vectors;

        vectors.push_back(new VectorWrapper<int>());
        vectors.push_back(new VectorWrapper<char>());
        vectors.push_back(new VectorWrapper<double>());

        for (int i=0; i < vectors.size(); ++i) {
            WrapperBase *v = vectors[i];
            if (dynamic_cast<VectorWrapper<int>*>(v) != 0) {
                std::cout << "It's an int vector.\n";
            }
            else if (dynamic_cast<VectorWrapper<char>*>(v) != 0) {
                std::cout << "It's a char vector.\n";
            }
            else if (dynamic_cast<VectorWrapper<double>*>(v) != 0) {
                std::cout << "It's a double vector.\n";
            }
        }

        for (int i=0; i < vectors.size(); ++i) {
            delete vectors[i];
        }
    }

但这有一些缺点：

你需要使用指针，所以要小心内存泄漏。
dynamic_cast可能会很慢，我不会在紧密循环中使用它。

Answer 3

从原始问题的对话线程中，我对问题的理解是你有一些“黑盒子”函数，它的接口是一个向量列表，其各个类型在运行时在接口的两侧都是已知的，但没有在界面本身中表示。

如果是这种情况，那么简单的union就足够了吗？例如（另）：

typedef union
{
    std::vector<char>    c;
    std::vector<int>     i;
    std::vector<float>   v;
} unknown_t;

std::list<unknown_t> my_list;

unknown_t u1;  // assume int
unknown_t u2;  // assume float

u1.i.push_back(5);
u1.i.push_back(10);

u2.f.push_back(23.4f);
u2.f.push_back(19.2f);
u2.f.push_back(1e6);

my_list.push_back(u1);
my_list.push_back(u2);

<强>更新

哦，废话，这不行。您不能将vector放在union中，因为它们具有复制构造函数。遗憾！

Answer 4

好的，我想我现在明白了。您应该为您可能遇到的每种类型的向量创建一个包装类，并使所有这些类继承自相同的基类，比如说AbstractVector。然后，您可以拥有一个AbstractVector对象列表。

不同的矢量类型列表？

4 个答案: