blocks|key|2047258|text|如果您存储的元素是boost::any或boost::variant，则可以间接存储异构数据。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2047259|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/html/any.html|1|http://www.boost.org/doc/html/variant.html^0|9|A|K|E|9|A|0|K|E|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]|$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

If the element you store would be a <a href="http://www.boost.org/doc/html/any.html" rel="nofollow"><code>boost::any</code></a> or <a href="http://www.boost.org/doc/html/variant.html" rel="nofollow"><code>boost::variant</code></a> then you can indirectly store heterogeneous data.

blocks|key|99450|text|标准库中的基本原则是“容器”是同构的；C%2B%2B标准不认为像std::pair或std::tuple这样的东西是容器。(我认为这张图具有误导性，因为它确实将它们视为容器。)如果您需要一个异构容器，则必须使用boost::variant容器，或者类似于这些内容的容器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|99451|entityMap^0|S|9|12|A|2T|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

The basic principle in the standard library is that "containers" are homogeneous; the C++ standard doesn't consider things like <code>std::pair</code> or <code>std::tuple</code> to be containers. (I'd consider the graph misleading, since it does consider them as containers.) If you need a heterogeneous container, you'd have to use a container of <code>boost::variant</code>, or something along those lines.

blocks|key|99985|text|一般来说，C%2B%2B容器被设计成使用模板来保存单一类型的对象。如果您想要从一种类型派生的不同类型，您可以存储一个指针容器(我猜您也可以有一个空的容器*到任何东西.)例如std::vector。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|99986|如果您想要完全无关的类型，您可以存储可以安全地引用这些其他类型的对象，例如boost::any。|99987|0/doc/html/any.html|offset|length|99988|boost站点上的一些示例：|99989|#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;
++++}
}|code-block|syntax|javascript|99990|rather：：variant类似，但是您指定了所有允许的类型，而不是允许容器中的任何类型。|99991|0/doc/html/variant.html|99992|std::vector<+boost::variant<unsigned,+std::string>+>+vec;
vec.push_back(+44);
vec.push_back(+"str"+);
vec.push_back(+SomthingElse(55,+65)+);+//not+allowed|99993|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_47_0/doc/html/any.html|1|http://www.boost.org/doc/libs/1_47_0/doc/html/variant.html^0|0|0|0|J|0|0|0|0|0|0|N|1|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@$F|17|G|18|1|19]]|A|$]]|$1|H|3|I|5|6|7|1A|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1B|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@$F|1E|G|1F|1|1G]]|A|$]]|$1|S|3|T|5|L|7|1H|8|@]|9|@]|A|$M|N]]|$1|U|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|X|Y|Z|A|$10|13]]]]

Well generally C++ Containers are designed to hold objects of a single type using templates. If you want different types that are all derived from one type you can store a container of pointers (I guess you could also have a container of void* to anything...) e.g. std::vector&lt;MyBaseType*&gt;.

If you want completely unrelated types, you can store objects that can safely reference those other types, such as boost::any.

<a href="http://www.boost.org/doc/libs/1_47_0/doc/html/any.html" rel="noreferrer">http://www.boost.org/doc/libs/1_47_0/doc/html/any.html</a>

Some examples off the boost site:

<pre><code>#include &lt;list&gt;
#include &lt;boost/any.hpp&gt;

using boost::any_cast;
typedef std::list&lt;boost::any&gt; many;

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

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

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

boost::variant is similar, but you specify all the allowed types, rather than allowing any type in your container.

<a href="http://www.boost.org/doc/libs/1_47_0/doc/html/variant.html" rel="noreferrer">http://www.boost.org/doc/libs/1_47_0/doc/html/variant.html</a>

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

blocks|key|99503|text|固定大小的异构容器(如std::tuple+)要求在编译时知道类型。如果您想要创建一个可变大小的异构容器，只需创建一个std::vector<std::tuple<T1,T2,...,TN>>即可。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|99504|如果您想要在编译时不知道类型的异构容器(无论是可变的还是固定大小的)，则必须将指针(或智能指针)存储到编译时已知的基类型，或者考虑类似于boost::any的容器。STL不直接提供这样一个容器，无论是固定的还是可变的，都是在运行时确定了异构元素的大小。|99505|entityMap^0|B|A|1N|11|0|1W|A|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

The fixed size heterogenous containers (like <code>std::tuple</code> require the types to be known at compile time. If you want to make a variable sized heterogeneous container, just make a <code>std::vector&lt;std::tuple&lt;T1,T2,...,TN&gt;&gt;</code>.

If you want a heterogeneous container where the types is not known at compile time (whether that would be variable or fixed sized) you'll have to store pointers (or smart pointers) to a base type known at compile time, or alternatively consider something like a container of <code>boost::any</code>. The STL doesn't directly provide such a container in either fixed or variable sized with heterogeneous elements determined at run time.

blocks|key|2047368|text|std::pair和std::tuple几乎不是C%2B%2B容器..。所以没有，在STL中没有异构的容器，因为没有必要让它们内置。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2047369|有几种方法可以创建这样的容器。我建议的办法是：|2047370|使用多态性|unordered-list-item|2047371|使用变体类型|2047372|对于多态性，您可以检查Boost指针容器库。|2047373|boost::ptr_vector<Base>+vec;
vec.push_back(new+Derived);
vec.push_back(new+Derived2);|code-block|syntax|javascript|2047374|它模仿STL容器，但提供了面向多态性的功能：|2047375|作为Base&的访问元素|2047376|自动内存处理|2047377|特定的复制行为(使用new_clone方法)|2047378|句法糖:给定boost::ptr_vector<Base>::iterator+it;，*it是Base&|2047379|如果您的类型无关，则另一种可能是使用Boost变体。基本上，一个变体类似于：|2047380|enum+{+Type1,+Type2,+...+}+_type;
union+{
++SomeType1+_1;
++SomeType2+_2;
++...
}+_u;|2047381|当然，由于它是boost，所以它提供了特定的保证，以确保您只能访问当前活动的联合成员，并取消对类的限制，构造函数/析构函数不能在传统的联合中使用。|2047382|它还提供了一些工具，比如static_visitor，它相当于类型上的一个开关，如果没有访问其中一个可能的状态，就会产生编译错误。|2047383|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_47_0/libs/ptr_container/doc/ptr_container.html|1|http://www.boost.org/doc/libs/1_47_0/doc/html/variant.html^0|0|9|A|A|0|0|0|0|B|9|0|0|0|0|2|5|0|0|A|9|0|6|11|18|3|1C|5|0|I|7|1|0|0|0|C|E|0^^$0|@$1|2|3|4|5|6|7|1L|8|@$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1R|8|@]|D|@]|E|$]]|$1|K|3|L|5|J|7|1S|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1T|8|@]|D|@$9|1U|A|1V|1|1W]]|E|$]]|$1|O|3|P|5|Q|7|1X|8|@]|D|@]|E|$R|S]]|$1|T|3|U|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|V|3|W|5|J|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|X|3|Y|5|J|7|22|8|@]|D|@]|E|$]]|$1|Z|3|10|5|J|7|23|8|@$9|24|A|25|B|C]]|D|@]|E|$]]|$1|11|3|12|5|J|7|26|8|@$9|27|A|28|B|C]|$9|29|A|2A|B|C]|$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|13|3|14|5|6|7|2D|8|@]|D|@$9|2E|A|2F|1|2G]]|E|$]]|$1|15|3|16|5|Q|7|2H|8|@]|D|@]|E|$R|S]]|$1|17|3|18|5|6|7|2I|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|2J|8|@$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|1B|3|-4|5|6|7|2M|8|@]|D|@]|E|$]]]|1C|$1D|$5|1E|1F|1G|E|$1H|1I]]|1J|$5|1E|1F|1G|E|$1H|1K]]]]

<code>std::pair</code> and <code>std::tuple</code> are hardly C++ containers.... so no, there is no heterogeneous containers in the STL, because it's not necessary to have them built-in.

There are several approaches to create such containers. The approaches I would recommend are:

<ul>
<li>using polymorphism</li>
<li>using a variant type</li>
</ul>

<hr>

For Polymorphism, you can check <a href="http://www.boost.org/doc/libs/1_47_0/libs/ptr_container/doc/ptr_container.html" rel="nofollow">Boost Pointer Container</a> library.

<pre><code>boost::ptr_vector&lt;Base&gt; vec;
vec.push_back(new Derived);
vec.push_back(new Derived2);
</code></pre>

It mimicks the STL containers, but provides functionalities geared toward polymorphism:

<ul>
<li>Access elements as <code>Base&amp;</code></li>
<li>Automatic memory handling</li>
<li>Specific copy behavior (using <code>new_clone</code> methods)</li>
<li>Syntactic sugar: given <code>boost::ptr_vector&lt;Base&gt;::iterator it;</code>, <code>*it</code> is a <code>Base&amp;</code></li>
</ul>

<hr>

If your types are unrelated, the other possibility is to use <a href="http://www.boost.org/doc/libs/1_47_0/doc/html/variant.html" rel="nofollow">Boost Variant</a>. Basically, a variant is similar to:

<pre><code>enum { Type1, Type2, ... } _type;
union {
 SomeType1 _1;
 SomeType2 _2;
 ...
} _u;
</code></pre>

Of course, since it's boost, it provides specific guarantees to make sure that you can only access the member of the union that is currently active and lifts the restriction on classes with constructors / destructors not being usable in traditional unions.

It also provides facilities, like the <code>static_visitor</code>, which is the equivalent of a switch on the type, and will make the compilation error out if one of the possible states is not visited.

blocks|key|100050|text|一个尚未被接受的图书馆。但被提议列入的目标是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|100051|集合/网站/doc/html/index.html|offset|length|100052|它提供了一个名为any_collection的很好的类，它允许通过boost::type_erasure::any：集合拥有一个异构容器。|100053|否则，在C%2B%2B17中有简单的实现方法：https://gieseanw.wordpress.com/2017/05/03/a-true-heterogeneous-container-in-c/|100054|引用上述文章的例子：|100055|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|code-block|syntax|javascript|100056|然后容易使用：|100057|andyg::heterogeneous_container+c;
c.push_back(1);
c.push_back(2.f);
c.push_back('c');
struct+LocalStruct{};
c.push_back(LocalStruct{});|100058|作者说这是一个玩具实现，但我认为这是实现它的一种非常聪明的方法，它比poly_collection或变体向量简单。|100059|entityMap|0|LINK|mutability|MUTABLE|url|http://rawgit.com/joaquintides/poly_collection/website/doc/html/index.html|1|http://rawgit.com/joaquintides/poly_collection/website/doc/html/poly_collection/tutorial.html#poly_collection.tutorial.basics.boost_any_collection|2|https://gieseanw.wordpress.com/2017/05/03/a-true-heterogeneous-container-in-c/^0|0|0|P|0|0|1M|2|1|0|J|26|2|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|F|3|G|5|6|7|1D|8|@]|9|@$D|1E|E|1F|1|1G]]|A|$]]|$1|H|3|I|5|6|7|1H|8|@]|9|@$D|1I|E|1J|1|1K]]|A|$]]|$1|J|3|K|5|6|7|1L|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1M|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1N|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|1O|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|1P|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]|16|$5|Z|10|11|A|$12|17]]]]

A library which is not yet accepted into Boost. But which was proposed for inclusion is targeted toward this : 

<a href="http://rawgit.com/joaquintides/poly_collection/website/doc/html/index.html" rel="noreferrer">http://rawgit.com/joaquintides/poly_collection/website/doc/html/index.html</a>

It provides a nice class named any_collection which allows one to have an heterogeneous container via boost::type_erasure::any :
<a href="http://rawgit.com/joaquintides/poly_collection/website/doc/html/poly_collection/tutorial.html#poly_collection.tutorial.basics.boost_any_collection" rel="noreferrer">http://rawgit.com/joaquintides/poly_collection/website/doc/html/poly_collection/tutorial.html#poly_collection.tutorial.basics.boost_any_collection</a>

Otherwise in C++17 there are simple way to implement this :
<a href="https://gieseanw.wordpress.com/2017/05/03/a-true-heterogeneous-container-in-c/" rel="noreferrer">https://gieseanw.wordpress.com/2017/05/03/a-true-heterogeneous-container-in-c/</a>

Quoting the example of the aforementioned article : 

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

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

Then usable easily : 

<pre><code>andyg::heterogeneous_container c;
c.push_back(1);
c.push_back(2.f);
c.push_back('c');
struct LocalStruct{};
c.push_back(LocalStruct{});
</code></pre>

The author states it's a toy implementation, but I think this is a really clever way to implement it, and has a simplicity advantage over poly_collection or a vector of variants.

blocks|key|223866|text|我会带你去这个图书馆。它被实现为真正的异构容器https://github.com/hosseinmoein/DataFrame，它不使用多态性，因此存储指针。它使用连续内存存储，就像std::vector一样。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|223867|您可以这样编写代码|223868|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));|code-block|syntax|javascript|223869|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/hosseinmoein/DataFrame^0|N|15|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

I would point you to this library. It is implemented to be true heterogeneous container
<a href="https://github.com/hosseinmoein/DataFrame" rel="nofollow noreferrer">https://github.com/hosseinmoein/DataFrame</a>
It does not use polymorphism and consequently store pointers. It uses continuous memory storage, just like a std::vector.

You can write code like this

<pre><code>typedef StdDataFrame&lt;unsigned long&gt; MyDataFrame;

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

I saw this nice graphic which classifies which STL container would suit based on different requirements of data such as:

-- Fixed Size Vs Variable size

-- Data of same tyme Vs different type

-- Sorted Vs unsorted data

-- Sequential Vs random access

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

I notice in that image, that C++ STL there is no container which is

<ol>
<li>Variable Size</li>
<li>Heterogenous (data of different types). </li>
</ol>

Doesn't C++ have something for this?

PS - There can be many permutations made out the different properties of the containers and many others too might not be provided in STL.

Heterogeneous containers in C++

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我看到了这个很好的图形，它根据不同的数据需求对STL容器进行分类，例如：-固定尺寸与可变尺寸-同一类型和不同类型的数据-排序与未排序数据-顺序与随机存取我在图中注意到，C++ STL没有容器可变尺寸异质性(不同类型的数据)。C++没有做这个的东西吗？PS -可以有许多排列，作出不同性质的容器和许多其他也可能没有提供的S...

问C++中的异构容器
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++中的异构容器EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++中的异构容器
EN