blocks|key|2083151|text|向量是一种模拟数组的数据结构。它的内部实际上是一个(动态)数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2083152|basic_string类表示一个字符序列。它包含序列的所有常见操作，此外，它还包含标准字符串操作，如搜索和连接。|2083153|你可以使用std::vector<int>+or+<float>+or+even+std::vector<+std::vector<T>+>来保存你想要的任何数据类型，但是basic_string只能用来表示“文本”。|offset|length|style|CODE|2083154|entityMap^0|0|0|5|1T|2E|C|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@$F|O|G|P|H|I]|$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

A vector is a data structure which simulates an array. Deep inside it is actually a (dynamic) Array.

The basic_string class represents a Sequence of characters. It contains all the usual operations of a Sequence, and, additionally, it contains standard string operations such as search and concatenation. 

You can use vector to keep whatever data type you want <code>std::vector&lt;int&gt; or &lt;float&gt; or even std::vector&lt; std::vector&lt;T&gt; &gt;</code> but a <code>basic_string</code> can only be used for representing "text".

blocks|key|176983|text|basic_string提供了许多特定于字符串的比较选项。您说得对，底层的内存管理接口非常相似，但是string包含许多额外的成员，比如c_str()，这对于向量来说没有任何意义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|176984|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|$]]

The basic_string provides many string-specific comparison options. You are right in that the underlying memory management interface is very similar, but string contains many additional members, like c_str(), that would make no sense for a vector.

blocks|key|2088450|text|关键的区别在于，当std::basic_string不能时，std::vector应该将其数据保存在连续内存中。结果是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2088451|std::vector<char>+v(+'a',+3+);
char*+x+=+&v[0];+//+valid

std::basic_string<char>+s(+"aaa"+);
char*+x2+=+&s[0];+++++//+doesn't+point+to+continuous+buffer
//For+example,+the+behavior+of+
std::cout+<<+*(x2%2B1);
//is+undefined.
const+char*+x3+=+s.c_str();+//+valid|code-block|syntax|javascript|2088452|On+practice+this+difference+is+not+so+important.|2088453|entityMap|0|LINK|mutability|MUTABLE|url|http://herbsutter.com/2008/04/07/cringe-not-vectors-are-guaranteed-to-be-contiguous/#comment-483^0|9|H|U|B|0|0|0|1C|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

The key difference is that <code>std::vector</code> should keep its data in continuous memory, when <code>std::basic_string</code> could not to. As a result:

<pre><code>std::vector&lt;char&gt; v( 'a', 3 );
char* x = &amp;v[0]; // valid

std::basic_string&lt;char&gt; s( "aaa" );
char* x2 = &amp;s[0]; // doesn't point to continuous buffer
//For example, the behavior of 
std::cout &lt;&lt; *(x2+1);
//is undefined.
const char* x3 = s.c_str(); // valid
</code></pre>

<a href="http://herbsutter.com/2008/04/07/cringe-not-vectors-are-guaranteed-to-be-contiguous/#comment-483" rel="nofollow">On practice this difference is not so important.</a>

blocks|key|2933972|text|basic_string为编译器和标准库实现提供了一些向量上的自由：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2933973|2933974|“小字符串优化”在字符串上有效，它允许实现在字符串较短时将实际字符串存储在string对象中，而不是指向字符串的指针。大致是这样的：|ordered-list-item|2933975|2933976|类字符串{+char长度；联合{+size_t+*+usedWhenStringIsLong；char+usedWhenStringIsShortsizeof(char*)；}；}；|2933977|在C%2B%2B03中，基础数组不需要是连续的。在当前的标准下，以类似于“绳子”的方式实现basic_string是可能的。(虽然没有人这样做，因为这会使成员std::basic_string::c_str()和std::basic_string::data()的实现成本太高。)|unordered-list-item|2933978|2933979|C%2B%2B11现在禁止这种行为。|2933980|在C%2B%2B03中，basic_string允许编译器/库供应商对数据使用写入时复制(这可以保存在副本上)，这对于std::vector是不允许的。在实践中，这曾经更常见，但现在不那么常见了，因为它对多线程有影响。但是，无论哪种方式，您的代码都不能依赖于std::basic_string是否使用COW实现。|2933981|2933982|C%2B%2B11现在再次禁止此行为。|2933983|也有一些附加到basic_string上的助手方法，但大多数都很简单，当然可以很容易地在vector之上实现。|2933984|entityMap^0|0|C|0|0|0|0|0|15|C|23|Q|2U|P|0|0|0|8|C|1J|B|3H|H|0|0|0|7|C|18|6|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|15|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|16|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|17|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1G|8|@]|D|@]|E|$]]|$1|S|3|T|5|O|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|1P|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|10|$]]

<code>basic_string</code> gives compiler and standard library implementations, a few freedoms over vector:

<ol>
<li>The "small string optimization" is valid on strings, which allows implementations to store the actual string, rather than a pointer to the string, in the string object when the string is short. Something along the lines of:

<pre><code>class string
{
 size_t length;
 union
 {
 char * usedWhenStringIsLong;
 char usedWhenStringIsShort[sizeof(char*)];
 };
};
</code></pre></li>
<li>In C++03, the underlying array need not be contiguous. Implementing <code>basic_string</code> in terms of something like a "rope" would be possible under the current standard. (Though nobody does this because that would make the members <code>std::basic_string::c_str()</code> and <code>std::basic_string::data()</code> too expensive to implement.) 
C++11 now bans this behavior though.</li>
<li>In C++03, <code>basic_string</code> allows the compiler/library vendor to use copy-on-write for the data (which can save on copies), which is not allowed for <code>std::vector</code>. In practice, this used to be a lot more common, but it's less common nowadays because of the impact it has upon multithreading. Either way though, your code cannot rely on whether or not <code>std::basic_string</code> is implemented using COW. 
C++11 again now bans this behavior.</li>
</ol>

There are a few helper methods tacked on to <code>basic_string</code> as well, but most are simple and of course could easily be implemented on top of <code>vector</code>.

blocks|key|2083220|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2083221|basic_string不调用其元素的构造函数和析构函数。|unordered-list-item|2083222|交换basic_string使迭代器无效(启用小字符串优化)，交换向量doesn't.|2083223|basic_string内存可能不会在C%2B%2B03中连续分配。向量总是连续的。在C%2B%2B0x+string.require中消除了这种差异：|2083224|2083225|basic_string对象中的类字符对象应连续存储在中|2083226|2083227|basic_string具有用于字符串操作的接口。矢量doesn't.|2083228|basic_string可以使用写入时拷贝策略(在C%2B%2B11之前)。向量不能。|2083229|2083230|非信仰者的相关语录：|2083231|basic.string|2083232|2083233|类模板basic_string符合顺序容器(23.2.3)、可逆容器(23.2)和支持分配器的容器(表99)的要求，只是basic_string不使用allocator_traits::construct和allocator_-+container：：destroy构造或销毁其元素，并且basic_string的swap()使迭代器无效。basic_string支持的迭代器是随机访问迭代器(24.2.7)。|blockquote|2083234|2083235|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|11|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|12|7|@]|8|@]|9|$]]|$1|D|3|E|4|C|6|13|7|@]|8|@]|9|$]]|$1|F|3|G|4|C|6|14|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|15|7|@]|8|@]|9|$]]|$1|I|3|J|4|5|6|16|7|@]|8|@]|9|$]]|$1|K|3|-4|4|5|6|17|7|@]|8|@]|9|$]]|$1|L|3|M|4|C|6|18|7|@]|8|@]|9|$]]|$1|N|3|O|4|C|6|19|7|@]|8|@]|9|$]]|$1|P|3|-4|4|5|6|1A|7|@]|8|@]|9|$]]|$1|Q|3|R|4|5|6|1B|7|@]|8|@]|9|$]]|$1|S|3|T|4|5|6|1C|7|@]|8|@]|9|$]]|$1|U|3|-4|4|5|6|1D|7|@]|8|@]|9|$]]|$1|V|3|W|4|X|6|1E|7|@]|8|@]|9|$]]|$1|Y|3|-4|4|5|6|1F|7|@]|8|@]|9|$]]|$1|Z|3|-4|4|5|6|1G|7|@]|8|@]|9|$]]]|10|$]]

<ul>
<li>basic_string doesn't call constructors and destructors of its elements. vector does.</li>
<li>swapping basic_string invalidates iterators (enabling small string optimization), swapping vectors doesn't.</li>
<li>basic_string memory may not be allocated continuously in C++03. vector is always continuous. This difference is removed in C++0x [string.require]:

<blockquote>
 The char-like objects in a basic_string object shall be stored contiguously
</blockquote></li>
<li>basic_string has interface for string operations. vector doesn't.</li>
<li>basic_string may use copy on write strategy (in pre C++11). vector can't.</li>
</ul>

Relevant quotes for non-believers:

[basic.string]:

<blockquote>
 The class template basic_string conforms to the requirements for a Sequence Container (23.2.3), for a
 Reversible Container (23.2), and for an Allocator-aware container (Table 99), except that basic_string
 does not construct or destroy its elements using allocator_traits::construct and allocator_-
 traits::destroy and that swap() for basic_string invalidates iterators. The iterators supported
 by basic_string are random access iterators (24.2.7).
</blockquote>

blocks|key|2083248|text|std::string和std::vector之间的一个不同之处在于，程序可以从以null结尾的字符串构造字符串，而使用向量则不能。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2083249|std::string+a+=+"hello";++++++++++//+okay
std::vector<char>+b+=+"goodbye";++//+compiler+error|code-block|syntax|javascript|2083250|这通常会使字符串更容易使用。|2083251|entityMap^0|0|B|C|B|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

One difference between <code>std::string</code> and <code>std::vector</code> is that programs may construct a string from a null-terminated string, whereas with vectors they cannot.

<pre><code>std::string a = "hello"; // okay
std::vector&lt;char&gt; b = "goodbye"; // compiler error
</code></pre>

This often makes strings easier to work with.

blocks|key|5047904|text|vector：TLDR被优化为只包含字符基元，TLDR可以包含基元或对象|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5047905|vector和string之间最大的区别是vector可以正确地包含对象，而string只适用于原语。因此，vector提供了这些方法，这些方法对于使用原语的string来说是无用的：|5047906|5047907|vector::emplace|ordered-list-item|5047908|vector::emplace_back|5047909|vector::~vector|5047910|5047911|即使扩展string也不允许它正确地处理对象，因为它缺少析构函数。这不应被视为缺点，它允许对vector进行重大优化，因为string可以：|5047912|5047913|Do+short+string+optimization，潜在地避免堆分配，使用little+to+no+increased+storage+overhead|5047914|Use+char_traits+(string的模板参数之一)来定义应该如何在所包含的原语上实现操作(其中只实现了char、wchar_t、char16_t和char32_t|5047915|5047916|特别相关的是char_traits::copy、char_traits::move和char_traits::assign，这显然意味着将使用直接赋值，而不是构造或销毁，这也是原语的首选。所有这些专门化对于string都有额外的缺点：|5047917|5047918|将仅使用char、wchar_t、char16_t或char32_t基元类型。显然，大小高达32位的原语可以使用其等效大小的char_type：https://stackoverflow.com/a/35555016/2642059，但是对于像long+long这样的原语，需要编写新的char_traits专门化，并且专门化char_traits::eof和char_traits::not_eof而不是仅仅使用vector<long+long>的想法似乎不是短字符串优化的time.|5047919|Because的最佳使用，迭代器被所有会使vector迭代器无效的操作无效，但是string迭代器还被<代码>C59和idea无效|5047920|5047921|vector和string接口的其他区别|5047922|5047923|没有可变的代码：Why+Doesn't+std::string.data()+provide+a+mutable+char*?|5047924|string提供了处理vector中不可用的单词的功能：string::c_str、string::length、string::append、string::operator%2B=、string::compare、C78、C79、C80、C81、C82、C83、C84、C85、C86、C87、C88、C89、C90、C91、C92、C93、C94、C95、C96、C96string::stold、stirng::to_string、string::to_wstring|5047925|Finally+everywhere+vector接受另一个vector的参数，string接受string或char*|5047926|5047927|注这个答案是针对C%2B%2B11编写的，因此需要连续分配string。|5047928|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/container/vector/emplace|1|http://en.cppreference.com/w/cpp/container/vector/emplace_back|2|http://en.cppreference.com/w/cpp/container/vector/~vector|3|https://stackoverflow.com/questions/10315041/meaning-of-acronym-sso-in-the-context-of-stdstring?lq=1|4|https://stackoverflow.com/a/28003328/2642059|5|https://stackoverflow.com/q/21694302/2642059|6|http://en.cppreference.com/w/cpp/string/char_traits/copy|7|http://en.cppreference.com/w/cpp/string/char_traits/move|8|http://en.cppreference.com/w/cpp/string/char_traits/assign|9|https://stackoverflow.com/a/35555016/2642059|10|http://en.cppreference.com/w/cpp/string/char_traits/eof|11|http://en.cppreference.com/w/cpp/string/char_traits/not_eof|12|https://stackoverflow.com/q/34155390/2642059|13|http://en.cppreference.com/w/cpp/string/basic_string/c_str|14|http://en.cppreference.com/w/cpp/string/basic_string/size|15|http://en.cppreference.com/w/cpp/string/basic_string/append|16|http://en.cppreference.com/w/cpp/string/basic_string/operator%252B%253D|17|http://en.cppreference.com/w/cpp/string/basic_string/compare|18|http://en.cppreference.com/w/cpp/string/basic_string/stof|19|http://en.cppreference.com/w/cpp/string/basic_string/to_string|20|http://en.cppreference.com/w/cpp/string/basic_string/to_wstring^0|0|6|0|0|6|7|6|L|6|12|6|1I|6|27|6|0|0|0|F|0|0|0|K|1|0|0|F|2|0|0|4|6|1A|6|1P|6|0|0|3|P|3|14|6|4|1E|T|5|0|4|B|H|6|1L|4|1Q|7|1Y|8|27|8|0|0|6|H|O|H|16|J|2V|6|6|H|6|O|H|7|16|J|8|0|0|4|4|9|7|H|8|Q|8|1Q|9|3E|9|3Z|B|4J|G|50|K|5R|H|20|18|9|4J|G|A|50|K|B|0|L|6|14|6|0|0|0|6|7|6|0|0|8|1J|C|0|0|6|B|6|S|D|16|E|1L|E|20|I|2J|F|56|D|5K|H|62|I|S|D|D|16|E|E|1L|E|F|20|I|G|2J|F|H|56|D|I|5K|H|J|62|I|K|0|J|6|U|6|14|6|1C|6|1J|5|0|0|P|6|0^^$0|@$1|2|3|4|5|6|7|2U|8|@$9|2V|A|2W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|2X|8|@$9|2Y|A|2Z|B|C]|$9|30|A|31|B|C]|$9|32|A|33|B|C]|$9|34|A|35|B|C]|$9|36|A|37|B|C]|$9|38|A|39|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|3A|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|3B|8|@]|D|@$9|3C|A|3D|1|3E]]|E|$]]|$1|L|3|M|5|K|7|3F|8|@]|D|@$9|3G|A|3H|1|3I]]|E|$]]|$1|N|3|O|5|K|7|3J|8|@]|D|@$9|3K|A|3L|1|3M]]|E|$]]|$1|P|3|-4|5|6|7|3N|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|3O|8|@$9|3P|A|3Q|B|C]|$9|3R|A|3S|B|C]|$9|3T|A|3U|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|3V|8|@]|D|@]|E|$]]|$1|T|3|U|5|K|7|3W|8|@]|D|@$9|3X|A|3Y|1|3Z]|$9|40|A|41|1|42]|$9|43|A|44|1|45]]|E|$]]|$1|V|3|W|5|K|7|46|8|@$9|47|A|48|B|C]|$9|49|A|4A|B|C]|$9|4B|A|4C|B|C]|$9|4D|A|4E|B|C]|$9|4F|A|4G|B|C]|$9|4H|A|4I|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|4J|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|4K|8|@$9|4L|A|4M|B|C]|$9|4N|A|4O|B|C]|$9|4P|A|4Q|B|C]|$9|4R|A|4S|B|C]]|D|@$9|4T|A|4U|1|4V]|$9|4W|A|4X|1|4Y]|$9|4Z|A|50|1|51]]|E|$]]|$1|10|3|-4|5|6|7|52|8|@]|D|@]|E|$]]|$1|11|3|12|5|K|7|53|8|@$9|54|A|55|B|C]|$9|56|A|57|B|C]|$9|58|A|59|B|C]|$9|5A|A|5B|B|C]|$9|5C|A|5D|B|C]|$9|5E|A|5F|B|C]|$9|5G|A|5H|B|C]|$9|5I|A|5J|B|C]|$9|5K|A|5L|B|C]|$9|5M|A|5N|B|C]]|D|@$9|5O|A|5P|1|5Q]|$9|5R|A|5S|1|5T]|$9|5U|A|5V|1|5W]]|E|$]]|$1|13|3|14|5|K|7|5X|8|@$9|5Y|A|5Z|B|C]|$9|60|A|61|B|C]]|D|@]|E|$]]|$1|15|3|-4|5|6|7|62|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|63|8|@$9|64|A|65|B|C]|$9|66|A|67|B|C]]|D|@]|E|$]]|$1|18|3|-4|5|6|7|68|8|@]|D|@]|E|$]]|$1|19|3|1A|5|K|7|69|8|@]|D|@$9|6A|A|6B|1|6C]]|E|$]]|$1|1B|3|1C|5|K|7|6D|8|@$9|6E|A|6F|B|C]|$9|6G|A|6H|B|C]|$9|6I|A|6J|B|C]|$9|6K|A|6L|B|C]|$9|6M|A|6N|B|C]|$9|6O|A|6P|B|C]|$9|6Q|A|6R|B|C]|$9|6S|A|6T|B|C]|$9|6U|A|6V|B|C]|$9|6W|A|6X|B|C]]|D|@$9|6Y|A|6Z|1|70]|$9|71|A|72|1|73]|$9|74|A|75|1|76]|$9|77|A|78|1|79]|$9|7A|A|7B|1|7C]|$9|7D|A|7E|1|7F]|$9|7G|A|7H|1|7I]|$9|7J|A|7K|1|7L]]|E|$]]|$1|1D|3|1E|5|K|7|7M|8|@$9|7N|A|7O|B|C]|$9|7P|A|7Q|B|C]|$9|7R|A|7S|B|C]|$9|7T|A|7U|B|C]|$9|7V|A|7W|B|C]]|D|@]|E|$]]|$1|1F|3|-4|5|6|7|7X|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|7Y|8|@$9|7Z|A|80|B|C]]|D|@]|E|$]]|$1|1I|3|-4|5|6|7|81|8|@]|D|@]|E|$]]]|1J|$1K|$5|1L|1M|1N|E|$1O|1P]]|1Q|$5|1L|1M|1N|E|$1O|1R]]|1S|$5|1L|1M|1N|E|$1O|1T]]|1U|$5|1L|1M|1N|E|$1O|1V]]|1W|$5|1L|1M|1N|E|$1O|1X]]|1Y|$5|1L|1M|1N|E|$1O|1Z]]|20|$5|1L|1M|1N|E|$1O|21]]|22|$5|1L|1M|1N|E|$1O|23]]|24|$5|1L|1M|1N|E|$1O|25]]|26|$5|1L|1M|1N|E|$1O|27]]|28|$5|1L|1M|1N|E|$1O|29]]|2A|$5|1L|1M|1N|E|$1O|2B]]|2C|$5|1L|1M|1N|E|$1O|2D]]|2E|$5|1L|1M|1N|E|$1O|2F]]|2G|$5|1L|1M|1N|E|$1O|2H]]|2I|$5|1L|1M|1N|E|$1O|2J]]|2K|$5|1L|1M|1N|E|$1O|2L]]|2M|$5|1L|1M|1N|E|$1O|2N]]|2O|$5|1L|1M|1N|E|$1O|2P]]|2Q|$5|1L|1M|1N|E|$1O|2R]]|2S|$5|1L|1M|1N|E|$1O|2T]]]]

<h1>TLDR: <code>string</code>s are optimized to only contain character primitives, <code>vector</code>s can contain primitives or objects</h1>

The preeminent difference between <code>vector</code> and <code>string</code> is that <code>vector</code> can correctly contain objects, <code>string</code> works only on primitives. So <code>vector</code> provides these methods that would be useless for a <code>string</code> working with primitives:

<ol>
<li><a href="http://en.cppreference.com/w/cpp/container/vector/emplace" rel="nofollow noreferrer">vector::emplace</a></li>
<li><a href="http://en.cppreference.com/w/cpp/container/vector/emplace_back" rel="nofollow noreferrer">vector::emplace_back</a></li>
<li><a href="http://en.cppreference.com/w/cpp/container/vector/~vector" rel="nofollow noreferrer">vector::~vector</a></li>
</ol>

Even extending <code>string</code> will not allow it to correctly handle objects, because it lacks a destructor. This should not be viewed as a drawback, it allows significant optimization over <code>vector</code> in that <code>string</code> can:

<ol>
<li>Do <a href="https://stackoverflow.com/questions/10315041/meaning-of-acronym-sso-in-the-context-of-stdstring?lq=1">short string optimization</a>, potentially avoiding heap allocation, with <a href="https://stackoverflow.com/a/28003328/2642059">little</a> to <a href="https://stackoverflow.com/q/21694302/2642059">no increased storage overhead</a></li>
<li>Use <code>char_traits</code>, one of <code>string</code>'s template arguments, to define how operations should be implemented on the contained primitives (of which only <code>char</code>, <code>wchar_t</code>, <code>char16_t</code>, and <code>char32_t</code> are implemented: <a href="http://en.cppreference.com/w/cpp/string/char_traits" rel="nofollow noreferrer">http://en.cppreference.com/w/cpp/string/char_traits</a>)</li>
</ol>

Particularly relevant are <a href="http://en.cppreference.com/w/cpp/string/char_traits/copy" rel="nofollow noreferrer"><code>char_traits::copy</code></a>, <a href="http://en.cppreference.com/w/cpp/string/char_traits/move" rel="nofollow noreferrer"><code>char_traits::move</code></a>, and <a href="http://en.cppreference.com/w/cpp/string/char_traits/assign" rel="nofollow noreferrer"><code>char_traits::assign</code></a> obviously implying that direct assignment, rather than construction or destruction will be used which is again, preferable for primitives. All this specialization has the additional drawbacks to <code>string</code> that:

<ol>
<li>Only <code>char</code>, <code>wchar_t</code>, <code>char16_t</code>, or <code>char32_t</code> primitives types will be used. Obviously, primitives of sizes up to 32-bit, could use their equivalently sized <code>char_type</code>: <a href="https://stackoverflow.com/a/35555016/2642059">https://stackoverflow.com/a/35555016/2642059</a>, but for primitives such as <code>long long</code> a new specialization of <code>char_traits</code> would need to be written, and the idea of specializing <a href="http://en.cppreference.com/w/cpp/string/char_traits/eof" rel="nofollow noreferrer"><code>char_traits::eof</code></a> and <a href="http://en.cppreference.com/w/cpp/string/char_traits/not_eof" rel="nofollow noreferrer"><code>char_traits::not_eof</code></a> instead of just using <code>vector&lt;long long&gt;</code> doesn't seem like the best use of time.</li>
<li>Because of short string optimization, iterators are invalidated by all the operations that would invalidate a <code>vector</code> iterator, but <code>string</code> iterators are additionally invalidated by <a href="http://en.cppreference.com/w/cpp/string/basic_string/swap" rel="nofollow noreferrer"><code>string::swap</code></a> and <a href="http://en.cppreference.com/w/cpp/string/basic_string/operator%3D" rel="nofollow noreferrer"><code>string::operator=</code></a></li>
</ol>

Additional differences in the interfaces of <code>vector</code> and <code>string</code>:

<ol>
<li>There is no mutable <code>string::data</code>: <a href="https://stackoverflow.com/q/34155390/2642059">Why Doesn&#39;t std::string.data() provide a mutable char*?</a></li>
<li><code>string</code> provides functionality for working with words unavailable in <code>vector</code>: <a href="http://en.cppreference.com/w/cpp/string/basic_string/c_str" rel="nofollow noreferrer"><code>string::c_str</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/size" rel="nofollow noreferrer"><code>string::length</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/append" rel="nofollow noreferrer"><code>string::append</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/operator%2B%3D" rel="nofollow noreferrer"><code>string::operator+=</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/compare" rel="nofollow noreferrer"><code>string::compare</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/replace" rel="nofollow noreferrer"><code>string::replace</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/substr" rel="nofollow noreferrer"><code>string::substr</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/copy" rel="nofollow noreferrer"><code>string::copy</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/find" rel="nofollow noreferrer"><code>string::find</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/rfind" rel="nofollow noreferrer"><code>string::rfind</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/find_first_of" rel="nofollow noreferrer"><code>string::find_first_of</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/find_first_not_of" rel="nofollow noreferrer"><code>string::find_first_not_of</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/find_last_of" rel="nofollow noreferrer"><code>string::flind_last_of</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/find_last_not_of" rel="nofollow noreferrer"><code>string::find_last_not_of</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/operator%2B" rel="nofollow noreferrer"><code>string::operator+</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/operator_ltltgtgt" rel="nofollow noreferrer"><code>string::operator&gt;&gt;</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/operator_ltltgtgt" rel="nofollow noreferrer"><code>string::operator&lt;&lt;</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/stol" rel="nofollow noreferrer"><code>string::stoi</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/stol" rel="nofollow noreferrer"><code>string::stol</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/stol" rel="nofollow noreferrer"><code>string::stoll</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/stoul" rel="nofollow noreferrer"><code>string::stoul</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/stoul" rel="nofollow noreferrer"><code>string::stoull</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/stof" rel="nofollow noreferrer"><code>string::stof</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/stof" rel="nofollow noreferrer"><code>string::stod</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/stof" rel="nofollow noreferrer"><code>string::stold</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/to_string" rel="nofollow noreferrer"><code>stirng::to_string</code></a>, <a href="http://en.cppreference.com/w/cpp/string/basic_string/to_wstring" rel="nofollow noreferrer"><code>string::to_wstring</code></a></li>
<li>Finally everywhere <code>vector</code> accepts arguments of another <code>vector</code>, <code>string</code> accepts a <code>string</code> or a <code>char*</code></li>
</ol>

Note this answer is written against C++11, so <code>string</code>s are required to be allocated contiguously.

What is the fundamental difference, if any, between a C++ std::vector and std::basic_string?

Vector vs string

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

C++ std::vector和std::basic_string之间的根本区别是什么？

问向量与字符串
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问向量与字符串EN