C++ 中的异构容器

Question

我看到了这个漂亮的图形，它根据数据的不同要求对适合哪个 STL 容器进行了分类，例如：

-- 固定大小 Vs 可变大小

-- 相同类型的数据 Vs 不同类型

-- 排序数据与未排序数据

-- 顺序访问与随机访问

< a href="http://plasmahh.projectiwear.org/cce_clean.svg" rel="noreferrer">http://plasmahh.projectiwear.org/cce_clean.svg

我注意到那个图像，C++ STL 没有

1. 可变大小
2. 异构的容器（不同类型的数据）。

C++ 没有这方面的东西吗？

PS - 容器的不同属性可能有多种排列，而 STL 中也可能未提供许多其他排列。

Answer 1

一般来说，C++ 容器被设计为使用模板保存单一类型的对象。如果您想要从一种类型派生的不同类型，您可以存储一个指针容器（我猜您也可以有一个 void* 到任何东西的容器...），例如 std::vector。

如果您想要完全不相关的类型，您可以存储可以安全引用其他类型的对象，例如 boost::any。

http://www.boost.org/doc/libs/1_47_0 /doc/html/any.html

boost 站点上的一些示例：

#include <list>
#include <boost/any.hpp>

using boost::any_cast;
typedef std::list<boost::any> many;

void append_int(many & values, int value)
{
    boost::any to_append = value;
    values.push_back(to_append);
}

void append_string(many & values, const std::string & value)
{
    values.push_back(value);
}

bool is_int(const boost::any & operand)
{
    return operand.type() == typeid(int);
}
bool is_char_ptr(const boost::any & operand)
{
    try
    {
        any_cast<const char *>(operand);
        return true;
    }
    catch(const boost::bad_any_cast &)
    {
        return false;
    }
}

boost::variant 类似，但您指定所有允许的类型，而不是允许容器中的任何类型。

http://www.boost.org/doc/libs/1_47_0 /doc/html/variant.html

std::vector< boost::variant<unsigned, std::string> > vec;
vec.push_back( 44);
vec.push_back( "str" );
vec.push_back( SomthingElse(55, 65) ); //not allowed

Answer 2

标准库的基本原则是“容器”是同质的； C++ 标准不认为 std::pair 或 std::tuple 之类的东西是容器。 （我认为该图具有误导性，因为它确实将它们视为容器。）如果您需要异构容器，则必须使用 boost::variant 容器，或类似的容器线。

Answer 3

尚未被 Boost 接受的库。但提议纳入的目标是：

http://rawgit。 com/joaquintides/poly_collection/website/doc/html/index.html

它提供了一个名为any_collection的好类，它允许通过 boost::type_erasure::any 拥有异构容器：
http://rawgit.com/joaquintides/poly_collection/website/doc/html/poly_collection/tutorial.html#poly_collection.tutorial.basics.boost_any_collection

否则在 C++17 中有简单的实现方法：
https://gieseanw.wordpress.com/ 2017/05/03/a-true-heterogeneous-container-in-c/

引用上述文章的例子：

namespace andyg{
struct heterogeneous_container{
private:
    template<class T>
    static std::unordered_map<const heterogeneous_container*, std::vector<T>> items;
public:
    template <class T>
    void push_back(const T& _t)
    {
        items<T>[this].push_back(_t);
    }
};

// storage for our static members
template<class T>
std::unordered_map<const heterogeneous_container*, std::vector<T>> heterogeneous_container::items;
} // andyg namespace

然后很容易使用：

andyg::heterogeneous_container c;
c.push_back(1);
c.push_back(2.f);
c.push_back('c');
struct LocalStruct{};
c.push_back(LocalStruct{});

作者声明这是一个玩具实现，但我认为这是一种非常聪明的实现方式，并且比 poly_collection 或变体向量具有简单性优势。

Answer 4

std::pair 和 std::tuple 几乎不是 C++ 容器......所以不，STL 中没有异构容器，因为没有必要拥有它们内置。

有多种方法可以创建此类容器。我推荐的方法是：

• 多态
• 使用变体类型使用

---

对于多态，您可以检查 Boost Pointer Container 库。

boost::ptr_vector<Base> vec;
vec.push_back(new Derived);
vec.push_back(new Derived2);

它模仿 STL 容器，但提供面向多态性的功能：

• 以 Base&
• 形式访问元素 自动内存处理
• 特定复制行为（使用 new_clone 方法）
• 语法糖：给定 boost::ptr_vector::iterator it;, *it 是一个 Base&

---

如果您的类型不相关，另一种可能性是使用 Boost 变体。基本上，一个变体类似于：

enum { Type1, Type2, ... } _type;
union {
  SomeType1 _1;
  SomeType2 _2;
  ...
} _u;

当然，由于它是 boost，它提供了特定的保证，以确保您只能访问当前活动的联合成员，并解除了对构造函数/析构函数不能在以下情况下使用的类的限制：传统工会。

它还提供了诸如static_visitor之类的功能，它相当于类型上的开关，并且如果未访问其中一种可能的状态，则会产生编译错误。

Answer 5

固定大小的异构容器（如 std::tuple ）要求在编译时知道类型。如果您想创建一个可变大小的异构容器，只需创建一个 std::vectorstd::tuple 即可。 std::tuple>

如果您想要一个异构容器，其中类型在编译时未知（无论是可变大小还是固定大小） 。必须存储指向编译时已知的基类型的指针（或智能指针），或者考虑类似boost::any 的容器。STL 不直接以固定或固定方式提供此类容器。大小可变，异构元素在运行时确定。

Answer 6

如果您存储的元素是 boost::any 或 boost::variant 那么你可以间接存储异构数据。

Answer 7

我会向您推荐这个图书馆。它被实现为真正的异构容器
https://github.com/hosseinmoein/DataFrame
它不使用多态性，因此存储指针。它使用连续的内存存储，就像 std::vector 一样。

你可以这样写代码

typedef StdDataFrame<unsigned long> MyDataFrame;

MyDataFrame                df;
std::vector<int>           intvec = { 1, 2, 3, 4, 5 };
std::vector<double>        dblvec = { 1.2345, 2.2345, 3.2345, 4.2345, 5.2345 };
std::vector<double>        dblvec2 = { 0.998, 0.3456, 0.056, 0.15678, 0.00345,
                                       0.923, 0.06743, 0.1 };
std::vector<std::string>   strvec = { "Insight", "John Dow", "Alakazam",
                                      "Persian Prince", "Bugs Bunny" };
std::vector<unsigned long> ulgvec = { 1UL, 2UL, 3UL, 4UL, 5UL, 8UL, 7UL, 6UL }
std::vector<unsigned long> xulgvec = ulgvec;

// This is only one way of loading data into a DataFrame instance. There are
// many different ways of doing it. Please see the documentation,
// or dataframe_tester.cc
int rc = df.load_data(std::move(ulgvec),  // Index column
                      std::make_pair("int_col", intvec),
                      std::make_pair("dbl_col", dblvec),
                      std::make_pair("dbl_col_2", dblvec2),
                      std::make_pair("str_col", strvec),
                      std::make_pair("ul_col", xulgvec));

Answer 8

注意到所有提到 boost::variant 的答案。

但从C++17开始，标准本身提供了std::variant。它是一个类型安全的联合。

    //A vector holds multiple types as declared in std::variant.
    std::vector<std::variant<int, double, std::string>> multiTypeVector;

    //Add eleemnts.
    multiTypeVector.push_back(8);
    multiTypeVector.push_back(8.0);
    multiTypeVector.push_back("test");
    multiTypeVector.push_back("test more");

    //Testing :: print elements.
    for (auto element : multiTypeVector)
        std::visit([](auto arg) {std::cout << arg << std::endl; }, element);