blocks|key|1391944|text|当你有很多插入或删除在中间的序列。例如一个记忆管理器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1391945|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

When you have a lot of insertion or deletion in the middle of the sequence. e.g. a memory manager.

blocks|key|1225408|text|在某些情况下，您想要在任何地方插入许多项，但要重复顺序的结尾。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1225409|检查每种不同类型的容器的复杂性保证：|1225410|标准容器的复杂性保证是什么？|offset|length|1225411|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/181693/what-are-the-complexity-guarantees-of-the-standard-containers^0|0|0|0|E|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Situations where you want to insert a lot of items into anywhere but the end of a sequence repeatedly.

Check out the complexity guarantees for each different type of container:

<a href="https://stackoverflow.com/questions/181693/what-are-the-complexity-guarantees-of-the-standard-containers">What are the complexity guarantees of the standard containers?</a>

blocks|key|2915757|text|任何时候，您都不能让迭代器失效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2915758|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Any time you cannot have iterators invalidated.

blocks|key|1225423|text|如果您不需要经常插入元素，那么向量就会更有效。它比列表具有更好的CPU缓存局部性。换句话说，访问一个元素很可能使下一个元素存在于缓存中，并且可以在不需要读取缓慢RAM的情况下被检索。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1225424|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you don't need to insert elements often then a vector will be more efficient. It has much better CPU cache locality than a list. In other words, accessing one element makes it very likely that the next element is present in the cache and can be retrieved without having to read slow RAM.

blocks|key|1392060|text|保持迭代器的有效性是使用列表的原因之一。另一种情况是，在推送项目时，不希望向量重新分配。这可以通过明智地使用reserve()来管理，但在某些情况下，只使用list可能更容易或更可行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1392061|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Preserving the validity of iterators is one reason to use a list. Another is when you don't want a vector to reallocate when pushing items. This can be managed by an intelligent use of reserve(), but in some cases it might be easier or more feasible to just use a list.

blocks|key|1226809|text|基本上，向量是一个具有自动内存管理的数组。数据在内存中是连续的。试图在中间插入数据是一项昂贵的操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226810|在列表中，数据存储在不相关的内存位置中。插入中间不需要复制一些数据来为新的数据腾出空间。|1226811|为了更具体地回答你的问题，我将引用此页的话|offset|length|1226812|向量通常是访问元素和从序列末尾添加或删除元素的最有效的时间。对于涉及在末端以外的位置插入或删除元素的操作，它们的执行情况比deques和list差，并且具有比lists更不一致的迭代器和引用。|blockquote|1226813|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/reference/stl/vector/^0|0|0|H|2|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@$F|V|G|W|1|X]]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Basically a vector is an array with automatic memory management. The data is contiguous in memory. Trying to insert data in the middle is a costly operation. 

In a list the data is stored in unrelated memory locations. Inserting in the middle doesn't involve copying some of the data to make room for the new one.

To answer more specifically your question I'll quote <a href="http://www.cplusplus.com/reference/stl/vector/" rel="noreferrer">this page</a>

<blockquote>
 vectors are generally the most efficient in time for accessing elements and to add or remove elements from the end of the sequence. For operations that involve inserting or removing elements at positions other than the end, they perform worse than deques and lists, and have less consistent iterators and references than lists.
</blockquote>

blocks|key|2915860|text|std::list的一个特殊功能是剪接(将列表的一部分或整个列表链接或移动到不同的列表中)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2915861|或者，如果您的内容是非常昂贵的复制。例如，在这种情况下，用列表对集合进行排序可能更便宜。|2915862|还要注意的是，如果集合很小(而且复制的内容并不特别昂贵)，即使您在任何地方插入和擦除，向量也可能优于列表。一个列表单独地分配每个节点，这可能比移动几个简单的对象花费更多。|2915863|我不认为有很严格的规则。这取决于您主要想对容器做什么，以及您期望容器的大小和包含的类型。向量通常优于列表，因为它将其内容分配为一个连续块(它基本上是一个动态分配的数组，而且在大多数情况下，数组是保存一堆东西的最有效方法)。|2915864|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

One special capability of std::list is splicing (linking or moving part of or a whole list into a different list).

Or perhaps if your contents are very expensive to copy. In such a case it might be cheaper, for example, to sort the collection with a list.

Also note that if the collection is small (and the contents are not particularly expensive to copy), a vector might still outperform a list, even if you insert and erase anywhere. A list allocates each node individually, and that might be much more costly than moving a few simple objects around.

I don't think there are very hard rules. It depends on what you mostly want to do with the container, as well as on how large you expect the container to be and the contained type. A vector generally trumps a list, because it allocates its contents as a single contiguous block (it is basically a dynamically allocated array, and in most circumstances an array is the most efficient way to hold a bunch of things).

blocks|key|2915866|text|当您想在容器之间移动对象时，可以使用list::splice。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2915867|例如，图分区算法可能具有在越来越多的容器中递归地分配的对象的常量。对象应该初始化一次，并且始终保持在内存中相同的位置。重新调整比重新分配要快得多。|2915868|编辑：作为库准备实现C%2B%2B0x，将子序列剪接到列表中的一般情况随着序列的长度而变得线性复杂。这是因为splice+(现在)需要迭代序列来计算其中的元素数。(因为列表需要记录其大小。)简单地计算和重新链接列表仍然比任何选择都要快，而拼接整个列表或单个元素是具有恒定复杂性的特殊情况。但是，如果你有很长的序列要拼接，你可能需要寻找一个更好的，老式的，不符合要求的容器。|BOLD|2915869|entityMap^0|I|C|0|0|0|3|1E|6|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|P|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Q|8|@$9|R|A|S|B|J]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|K|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|L|$]]

When you want to move objects between containers, you can use <code>list::splice</code>.

For example, a graph partitioning algorithm may have a constant number of objects recursively divided among an increasing number of containers. The objects should be initialized once and always remain at the same locations in memory. It's much faster to rearrange them by relinking than by reallocating.

Edit: as libraries prepare to implement C++0x, the general case of splicing a subsequence into a list is becoming linear complexity with the length of the sequence. This is because <code>splice</code> (now) needs to iterate over the sequence to count the number of elements in it. (Because the list needs to record its size.) Simply counting and re-linking the list is still faster than any alternative, and splicing an entire list or a single element are special cases with constant complexity. But, if you have long sequences to splice, you might have to dig around for a better, old-fashioned, non-compliant container.

blocks|key|1226854|text|我们班的学生似乎无法向我解释什么时候使用向量更有效，但是当建议我使用列表时，他们看起来很高兴。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226855|我就是这么理解的|1226856|List：每个项目都包含一个指向下一个或前一个元素的地址，因此通过这个特性，您可以将项目随机化，即使它们没有被排序，顺序也不会改变:如果您的内存是支离破碎的，它是有效的。但是它还有另一个非常大的优点:您可以很容易地插入/删除项，因为您只需要更改一些指针。缺点:要阅读一个随机项目，你必须从一个项目跳到另一个项目，直到你找到正确的地址。|offset|length|style|BOLD|1226857|向量：当使用向量时，内存比常规数组组织得多:每个第n项都存储在(n-1)项之后和(n%2B1)th项之前。为什么它比列表好？因为它允许快速随机访问。下面是这样的方法:如果你知道一个向量中一个项目的大小，如果它们在内存中是连续的，你可以很容易地预测第n项在哪里；你不需要浏览列表中的所有条目就能读取你想要的条目，用向量直接读取它，用一个你无法读取的列表。另一方面，修改向量数组或更改一个值要慢得多。|1226858|列表更适合跟踪可以在内存中添加/删除的对象。当您想要从大量的单个项访问元素时，向量更合适。|1226859|我不知道列表是如何被优化的，但是你必须知道如果你想要快速读取访问，你应该使用向量，因为STL有多好地固定列表，它在读取访问方面不会比向量更快。|1226860|entityMap^0|0|0|0|4|0|0|2|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@$F|U|G|V|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@$F|X|G|Y|H|I]]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|10|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|Q|$]]

Well the students of my class seems quite unable to explain to me when it is more effective to use vectors, but they look quite happy when advising me to use lists.

This is how I understand it

Lists:
Each item contains an address to the next or previous element, so with this feature, you can randomize the items, even if they aren't sorted, the order won't change: it's efficient if you memory is fragmented.
But it also has an other very big advantage: you can easily insert/remove items, because the only thing you need to do is change some pointers.
Drawback:
To read a random single item, you have to jump from one item to another until you find the correct address.

Vectors:
When using vectors, the memory is much more organized like regular arrays: each n-th items is stored just after (n-1)th item and before (n+1)th item.
Why is it better than list ?
Because it allow fast random access.
Here is how: if you know the size of an item in a vector, and if they are contiguous in memory, you can easily predict where the n-th item is; you don't have to browse all the item of a list to read the one you want, with vector, you directly read it, with a list you can't.
On the other hand, modify the vector array or change a value is much more slow.

Lists are more appropriate to keep track of objects which can be added/removed in memory.
Vectors are more appropriate when you want to access an element from a big quantity of single items.

I don't know how lists are optimized, but you have to know that if you want fast read access, you should use vectors, because how good the STL fasten lists, it won't be as fast in read-access than vector.

blocks|key|1392161|text|这里的大多数答案都忽略了一个重要的细节:为什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1392162|你想把什么放在集装箱里？|1392163|如果它是int的集合，那么std::list在每个场景中都会丢失，不管您是否可以重新分配，您只能从前面删除等等。列表遍历速度较慢，每次插入都需要与分配器进行交互。要准备一个list<int>胜过vector<int>的例子将是非常困难的。即使如此，deque<int>也可能更好或更接近，而不是限制列表的使用，这将带来更大的内存开销。|offset|length|style|CODE|1392164|然而，如果您正在处理大的、丑陋的数据块--而且很少--您不希望在插入时过多分配，而由于重新分配而进行复制将是一场灾难--那么使用list<UglyBlob>可能比使用vector<UglyBlob>更好。|1392165|尽管如此，如果您切换到vector<UglyBlob*>，甚至是vector<shared_ptr<UglyBlob>+>，那么列表将再次落后。|1392166|因此，访问模式、目标元素计数等仍然会影响比较，但在我看来--元素大小--复制成本等等。|1392167|entityMap^0|0|0|4|3|D|9|2E|9|2P|B|3G|A|0|1S|E|2B|G|0|B|H|W|T|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@$F|U|G|V|H|I]|$F|W|G|X|H|I]|$F|Y|G|Z|H|I]|$F|10|G|11|H|I]|$F|12|G|13|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|14|8|@$F|15|G|16|H|I]|$F|17|G|18|H|I]]|9|@]|A|$]]|$1|L|3|M|5|6|7|19|8|@$F|1A|G|1B|H|I]|$F|1C|G|1D|H|I]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1E|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|Q|$]]

Most answers here miss one important detail: what for?

What do you want to keep in the containter?

If it is a collection of <code>int</code>s, then <code>std::list</code> will lose in every scenario, regardless if you can reallocate, you only remove from the front, etc. Lists are slower to traverse, every insertion costs you an interaction with the allocator. It would be extremely hard to prepare an example, where <code>list&lt;int&gt;</code> beats <code>vector&lt;int&gt;</code>. And even then, <code>deque&lt;int&gt;</code> may be better or close, not justyfing the use of lists, which will have greater memory overhead.

However, if you are dealing with large, ugly blobs of data - and few of them - you don't want to overallocate when inserting, and copying due to reallocation would be a disaster - then you may, maybe, be better off with a <code>list&lt;UglyBlob&gt;</code> than <code>vector&lt;UglyBlob&gt;</code>.

Still, if you switch to <code>vector&lt;UglyBlob*&gt;</code> or even <code>vector&lt;shared_ptr&lt;UglyBlob&gt; &gt;</code>, again - list will lag behind.

So, access pattern, target element count etc. still affects the comparison, but in my view - the elements size - cost of copying etc.

blocks|key|2915963|text|必须使用list的唯一硬规则是需要在何处分发指向容器元素的指针。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2915964|与vector不同，您知道元素的内存不会重新分配。如果可以的话，那么您可能有指向未使用内存的指针，这充其量是一个大的不-不，最坏的情况是一个SEGFAULT。|2915965|(从技术上讲，vector+of+*_ptr也可以工作，但在这种情况下，您是在模仿list，所以这只是语义。)|2915966|其他软规则与将元素插入容器中间的可能的性能问题有关，因此最好使用list。|2915967|entityMap^0|4|4|0|1|6|1Y|8|0|7|6|H|5|15|4|0|W|4|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|M|$]]

The only hard rule where <code>list</code> must be used is where you need to distribute pointers to elements of the container. 

Unlike with <code>vector</code>, you know that the memory of elements won't be reallocated. If it could be then you might have pointers to unused memory, which is at best a big no-no and at worst a <code>SEGFAULT</code>.

(Technically a <code>vector</code> of <code>*_ptr</code> would also work but in that case you are emulating <code>list</code> so that's just semantics.)

Other soft rules have to do with the possible performance issues of inserting elements into the middle of a container, whereupon <code>list</code> would be preferable.

blocks|key|1225503|text|列表只是stl中双LinkedList的包装器，因此提供了您可能期望从d链接列表中获得的特性，即O(1)插入和删除。而向量是具有传染性的数据序列，它的工作方式类似于动态排列。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1225504|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Lists are just a wrapper for a doubly-LinkedList in stl, thus offering feature you might expect from d-linklist namely O(1) insertion and deletion.
While vectors are contagious data sequence which works like a dynamic array.P.S- easier to traverse.

blocks|key|2916036|text|就向量和列表而言，我发现的主要区别如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2916037|向量|offset|length|style|BOLD|2916038|向量将其元素存储在连续内存中。因此，在向量内随机访问是可能的，这意味着访问向量的元素非常快，因为我们可以简单地将基地址与项索引相乘来访问该元素。事实上，它只需要O(1)或恒定的时间来达到这个目的。|unordered-list-item|2916039|由于向量基本上是封装数组的，所以每次在向量(动态数组)中插入一个元素时，它都必须通过找到一个新的连续内存块来调整自身的大小，以适应新的元素，这是非常耗时的。|2916040|它不会消耗额外的内存来存储指向其中其他元素的任何指针。|2916041|列表|2916042|列表将其元素存储在非连续内存中。因此，随机访问在列表中是不可能的，这意味着要访问它的元素，我们必须使用指针并遍历相对于向量比较慢的列表。这需要O(n)或比O(1)慢的线性时间。|2916043|由于列表使用的是非连续内存，因此在列表中插入元素所需的时间比向量对应的要高得多，因为这样就避免了内存的重新分配。|2916044|它消耗额外的内存来存储指向特定元素之前和之后的指针。|2916045|因此，考虑到这些差异，我们通常考虑内存、频繁随机访问和插入来确定给定场景中向量与列表的胜利者。|2916046|entityMap^0|0|0|2|0|0|0|0|0|2|0|0|0|0|H|2|M|4|R|2|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$]]|$1|K|3|L|5|J|7|15|8|@]|9|@]|A|$]]|$1|M|3|N|5|J|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|17|8|@$D|18|E|19|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1A|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|1B|8|@]|9|@]|A|$]]|$1|U|3|V|5|J|7|1C|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1D|8|@$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]|$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|Z|$]]

In the case of a vector and list, the main differences that stick out to me are the following:

vector

<ul>
<li>A vector stores its elements in contiguous memory. Therefore, random
access is possible inside a vector which means that accessing an
element of a vector is very fast because we can simply multiply the
base address with the item index to access that element. In fact, it
takes only O(1) or constant time for this purpose.</li>
<li>Since a vector basically wraps an array, every time you insert an
element into the vector (dynamic array), it has to resize itself by
finding a new contiguous block of memory to accommodate the new
elements which is time-costly.</li>
<li>It does not consume extra memory to store any pointers to other
elements within it.</li>
</ul>

list

<ul>
<li>A list stores its elements in non-contiguous memory. Therefore,
random access is not possible inside a list which means that to
access its elements we have to use the pointers and traverse
the list which is slower relative to vector. This takes O(n) or linear time which is
slower than O(1).</li>
<li>Since a list uses non-contiguous memory, the time taken to insert an
element inside a list is a lot more efficient than in the case of its
vector counterpart because reallocation of memory is avoided.</li>
<li>It consumes extra memory to store pointers to the element before and
after a particular element.</li>
</ul>

So, keeping these differences in mind, we usually consider memory, frequent random access and insertion to decide the winner of vector vs list in a given scenario.

blocks|key|2916070|text|使它变得简单-|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2916071|一天结束时，当您在C%2B%2B中选择容器时，请使用以下流程图图(向我表示感谢)+:-|2916072|​|2916073|📷|atomic|2916074|2916075|向量-|2916076|矢量是基于接触记忆的|ordered-list-item|2916077|向量是用于小数据集的方法。|2916078|向量在数据集上遍历时执行最快。|2916079|在庞大的数据集上，向量插入删除速度较慢，但对于非常小的数据集，则速度较快。|2916080|列表-|2916081|列表基于堆内存。|2916082|列表对于非常庞大的数据集是可行的。|2916083|list在小数据集中的遍历速度相对较慢，但在大型数据集中的遍历速度较快。|2916084|列表插入删除对于庞大的数据集来说是快速的，但是对于较小的数据集则是缓慢的。|2916085|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/acabd4df502d1c770086bb65aace6398.png|imageAlt^0|0|7|0|0|0|0|1|0|0|0|0|3|0|0|0|0|0|0|3|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1K|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1L|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1M|8|@]|D|@$9|1N|A|1O|1|1P]]|E|$]]|$1|M|3|I|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|R|7|1U|8|@]|D|@]|E|$]]|$1|S|3|T|5|R|7|1V|8|@]|D|@]|E|$]]|$1|U|3|V|5|R|7|1W|8|@]|D|@]|E|$]]|$1|W|3|X|5|R|7|1X|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1Y|8|@$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|10|3|11|5|R|7|21|8|@]|D|@]|E|$]]|$1|12|3|13|5|R|7|22|8|@]|D|@]|E|$]]|$1|14|3|15|5|R|7|23|8|@]|D|@]|E|$]]|$1|16|3|17|5|R|7|24|8|@]|D|@]|E|$]]|$1|18|3|-4|5|6|7|25|8|@]|D|@]|E|$]]]|19|$1A|$5|1B|1C|1D|E|$1E|1F|1G|-4]]]]

Make it simple- 
At the end of the day when you are confused choosing containers in C++ use this flow chart image ( Say thanks to me ) :-
<a href="https://i.stack.imgur.com/Px7uf.png" rel="noreferrer"><img src="https://i.stack.imgur.com/Px7uf.png" alt="enter image description here" /></a>
Vector-
<ol>
<li>vector is based on contagious memory</li>
<li>vector is way to go for small data-set</li>
<li>vector perform fastest while traversing on data-set</li>
<li>vector insertion deletion is slow on huge data-set but fast for very
small</li>
</ol>
List-
<ol>
<li>list is based on heap memory</li>
<li>list is way to go for very huge data-set</li>
<li>list is comparatively slow on traversing small data-set but fast at
huge data-set</li>
<li>list insertion deletion is fast on huge data-set but slow on smaller
ones</li>
</ol>

blocks|key|2916096|text|List是双链接列表，因此很容易插入和删除元素。我们只需更改几个指针，而在向量中，如果我们想在中间插入一个元素，那么在它之后的每个元素必须移动一个索引。另外，如果向量的大小是满的，那么它必须首先增加它的大小。所以这是个昂贵的手术。因此，在这样的案例列表中，凡需要更频繁地执行插入和删除操作的地方，都应该使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2916097|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

List is Doubly Linked List so it is easy to insert and delete an element. We have to just change the few pointers, whereas in vector if we want to insert an element in the middle then each element after it has to shift by one index. Also if the size of the vector is full then it has to first increase its size. So it is an expensive operation.
So wherever insertion and deletion operations are required to be performed more often in such a case list should be used.

I noticed in Effective STL that 

<blockquote>
 vector is the type of sequence that
 should be used by default.
</blockquote>

What's does it mean? It seems that ignore the efficiency <code>vector</code> can do anything. 

Could anybody offer me a scenario where <code>vector</code> is not a feasible option but <code>list</code> must be used?

vector vs. list in STL

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我在有效的STL中注意到向量是默认情况下应该使用的序列类型。这是什么意思？似乎忽略效率，vector可以做任何事情。有人能给我提供一个场景，vector不是一个可行的选项，但必须使用list？

问STL中的向量与列表
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问STL中的向量与列表EN