blocks|key|592216|text|一个很好的免费在线资源是Bruce的"Thinking+in+C%2B%2B“，他的网站在这里：http://mindview.net/Books/TICPP/ThinkingInCPP2e.html。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|592217|他的免费书的第二卷反映在这里：ftnref14。第三章是关于字符串类，为什么它是一个模板，为什么它是有用的。|592218|entityMap|0|LINK|mutability|MUTABLE|url|http://mindview.net/Books/TICPP/ThinkingInCPP2e.html|1|http://www.smart2help.com/e-books/ticpp-2nd-ed-vol-two/#_ftnref14^0|18|1G|0|0|F|8|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

A good free online resource is "Thinking in C++" by Bruce Eckel, whose site is here: <a href="http://mindview.net/Books/TICPP/ThinkingInCPP2e.html" rel="nofollow">http://mindview.net/Books/TICPP/ThinkingInCPP2e.html</a> . 

The second volume of his free book is mirrored here: <a href="http://www.smart2help.com/e-books/ticpp-2nd-ed-vol-two/#_ftnref14" rel="nofollow">http://www.smart2help.com/e-books/ticpp-2nd-ed-vol-two/#_ftnref14</a> . Chapter three is all about the string class, why it's a template, and why it's useful.

blocks|key|1790651|text|string不是模板，string是用于char的basic_string类模板的专门化。它是一个模板，例如，您可以使用wstring+(专门处理宽字符)，并将所有相同的代码用于封装的值。|type|ordered-list-item|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1790652|见@Gman的评论。编译时代码重用，同时保留选择性特例的能力，是模板的基本原理.|BOLD|1790653|与实现有关。有些只进行单实例分配，只需编写副本.有些人对小字符串使用内置缓冲区，只有在达到一定大小后才从堆中分配。我建议您通过在<string>中遍历构造函数和后续代码来研究它在编译器上的工作方式，因为这将帮助您理解2.+hands，这比仅仅阅读它更有价值(尽管一本书或其他阅读对于模板介绍来说是一个很好的主意)。|1790654|因为const+char*和支持它的CRT是不小心的人的错误场。看看你从std:string免费得到的所有东西。加上一个与一堆标准的C%2B%2B算法迭代器一起工作的string。|1790655|unstyled|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/5zz6weyz.aspx|1|http://msdn.microsoft.com/en-us/library/chzkfc23.aspx^0|0|6|B|6|K|4|P|C|1O|7|0|A|3|0|1S|8|0|2|B|27|6|10|A|0|1P|A|1|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|18|8|@$9|19|A|1A|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@$9|1J|A|1K|1|1L]|$9|1M|A|1N|1|1O]]|E|$]]|$1|M|3|-4|5|N|7|1P|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]|V|$5|Q|R|S|E|$T|W]]]]

<ol>
<li><code>string</code> is not the template, <code>string</code> is a specialization of the <code>basic_string</code> class template for <code>char</code>. It's a template so that for example you can typedef <code>wstring</code> which specializes on wide characters, and use all the same code for the encapsulated value.</li>
<li>See @Gman's comment. Compile-time code reuse, while retaining the ability to selectively special-case, is the basic rationale for templates.</li>
<li>Implementation dependent. Some do single-instance allocation, with copy on write. Some use a builtin buffer for small strings and allocate from heap only after a certain size is reached. I suggest you investigate how it works on your compiler by walking the constructor and follow-on code in <code>&lt;string&gt;</code>, as that will help you understand 2. hands on, which is way more valuable than just reading about it (though a book or other reading is a great idea for intro to templates).</li>
<li>Because <code>const char*</code> and the CRT that supports it is a bug farm for the unwary. Check out all the stuff you get for free with <a href="http://msdn.microsoft.com/en-us/library/5zz6weyz.aspx" rel="nofollow">std::string</a>. Plus a <a href="http://msdn.microsoft.com/en-us/library/chzkfc23.aspx" rel="nofollow">whole bunch of Standard C++ algorithms</a> that work with <code>string</code> iterators.</li>
</ol>

blocks|key|592341|text|std::string实际上是std::basic_string<char>的typedef，其中包含了上面#1的答案。它是一个模板，以便使basic_string能够与几乎所有的东西一起工作。char，unsigned+char，wchar_t，pizza，不管.string本身只是一个程序员的方便，它使用char作为数据类型，因为这是人们经常想要的。|type|ordered-list-item|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|592342|无法回答的问题。如果你对某件事感到困惑，请尽量缩小范围。|592343|有两个答案。首先，从应用程序层的角度来看，所有basic_string对象都使用一个allocator对象来执行实际的分配。分配方法可能因实现而异，对于不同的模板参数，但实际上它们将在较低级别使用new来分配和管理所包含的资源。|592344|由于各种各样的原因，它比单纯的char数组更好。|592345|-+`string`+managers+the+memory+for+you.++You+do+not+have+to+ever+allocate+buffer+space+when+you+add+or+remove+data+to+the+string.++If+you+add+more+than+will+fit+in+the+currently-allocated+buffer,+`string`+will+reallocate+it+for+you+behind+the+scenes.
-+In+this+regard,+`string`+can+be+thought+of+as+a+kind+of+smart+pointer.++For+the+same+reasons+why+smart+pointers+are+better+than+raw+pointers,+`string`+s+are+better+than+raw+char+arrays.
-+Type+safety.++This+may+seem+a+little+convoluted,+but+`string`+used+properly+has+better+type+safety+than+char+buffers.++Consider+a+common+scenario:|code-block|syntax|javascript|592346|​|unstyled|592347|+#include+<string>
+#include+<sstream>
+using+namespace+std;

+int+main()
+{
+++const+char*+jamorkee_raw+=+"jamorkee";

+++char+raw_buf[0x1000]+=+{};
+++sprintf(+raw_buf,+"This+is+my+string.++Hello,+%25f",+jamorkee_raw);++

+++const+string+jamorkee_str+=+"jamorkee";
+++stringstream+ss;
+++ss+<<+"This+is+my+string.++Hello+"+<<+jamorkee_str;+
+++string+s+=+ss.str();
+}|592348|在使用string和流时，使用原始字符缓冲区引发的类型安全问题甚至是不可能的。|592349|entityMap^0|0|B|F|N|13|7|1Y|C|2P|4|2U|D|38|7|3G|5|3P|6|4B|4|0|0|N|C|16|9|2Q|3|0|0|0|0|0|3|6|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$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|@$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1S|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1T|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|S|7|1U|8|@]|D|@]|E|$]]|$1|T|3|U|5|N|7|1V|8|@]|D|@]|E|$O|P]]|$1|V|3|W|5|S|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|S|7|1Z|8|@]|D|@]|E|$]]]|Y|$]]

<ol>
<li><code>std::string</code> is actually a <code>typedef</code> to a <code>std::basic_string&lt;char&gt;</code>, and therein lies the answer to your #1 above. Its a template in order to make <code>basic_string</code> work with pretty much anything. <code>char</code>, <code>unsigned char</code>, <code>wchar_t</code>, <code>pizza</code>, whatever... <code>string</code> itself is just a programmer convenience that uses <code>char</code> as the datatype, since that's what's often wanted.</li>
<li>Unanswerable as asked. If you're confused about something, please try to narrow it down a bit.</li>
<li>There are two answers. One, from the application-layer point of view, all <code>basic_string</code> objects use an <code>allocator</code> object to do the actual allocation. Allocation methods may vary from one implementation to the next, and for different template parameters, but in practice they will use <code>new</code> at the lower levels to allocate &amp; manage the contained resource.</li>
<li>Its better than mere char arrays for a wide variety of reasons.

<ul>
<li><code>string</code> managers the memory for you. You do not have to ever allocate buffer space when you add or remove data to the string. If you add more than will fit in the currently-allocated buffer, <code>string</code> will reallocate it for you behind the scenes.</li>
<li>In this regard, <code>string</code> can be thought of as a kind of smart pointer. For the same reasons why smart pointers are better than raw pointers, <code>string</code> s are better than raw char arrays.</li>
<li>Type safety. This may seem a little convoluted, but <code>string</code> used properly has better type safety than char buffers. Consider a common scenario:</li>
</ul></li>
</ol>

&nbsp;

<pre><code> #include &lt;string&gt;
 #include &lt;sstream&gt;
 using namespace std;

 int main()
 {
 const char* jamorkee_raw = "jamorkee";

 char raw_buf[0x1000] = {};
 sprintf( raw_buf, "This is my string. Hello, %f", jamorkee_raw); 

 const string jamorkee_str = "jamorkee";
 stringstream ss;
 ss &lt;&lt; "This is my string. Hello " &lt;&lt; jamorkee_str; 
 string s = ss.str();
 }
</code></pre>

the type safety issue raised in the above by using a raw char buffer isn't even possible when using <code>string</code> along with streams.

blocks|key|1790758|text|在回答一些问题时，一个相当迅速的(因此可能是不完全)的尝试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1790759|blockquote|1790760|为什么它被编码为模板呢？|ordered-list-item|1790761|模板为类函数提供了处理任意数据类型的功能。例如，basic_string<>模板类可以在char单元上工作(这是std::string+type所做的)、wchar_t单元(std::wstring)或任何std::string类型。使用char或wchar_t以外的其他东西是不寻常的(更有可能使用std::vector<>)，但这种可能性是存在的。|offset|length|style|CODE|1790762|1790763|我是怎么分配的？|1790764|这不是标准所规定的。实际上，basic_string<>模板允许使用任意的分配器来实际分配内存(但不能确定可能请求分配的点)。有些实现可能在实际的类成员中存储短字符串，并且只在字符串超过一定大小时动态分配。所请求的大小可能正是存储字符串的需要，也可能是大小的倍数，以便在不重新分配的情况下允许增长。|1790765|从另一个如此回答窃取的其他信息|1790766|斯科特·迈耶的书“有效的STL”有一个关于std::string实现的章节，它很好地概述了常见的变体：“项目15:注意字符串实现中的变化”。|1790767|他谈到了四个变体：|1790768|ref计数实现上的几个变体(通常称为写上的复制)--当字符串对象未被复制时，回填数会增加，但实际的字符串数据不会增加。这两个对象都指向相同的重算数据，直到其中一个对象修改它，从而导致数据的“在写时复制”。不同的地方，如倒计时，锁等被储存。|unordered-list-item|1790769|“短字符串优化”实现。在这个变体中，对象包含通常指向数据、长度、动态分配缓冲区大小等的指针。但是，如果字符串足够短，它将使用该区域来保存字符串，而不是动态分配缓冲区。|1790770|1790771|为什么(不是)比仅为空终止的char数组更好？|1790772|string类比仅以空结尾的数组更好的一种方法是，类管理所需的内存，因此减少了涉及分配错误或超出分配数组结束的缺陷。另一个(可能是次要的)好处是，您可以在字符串中存储'null‘字符。一个缺点是，可能存在一些开销--特别是您几乎必须依赖于string类的动态内存分配。在大多数情况下，这可能不是一个主要问题，在一些设置(例如嵌入式系统)上，这可能是一个问题。|1790773|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1466073/how-is-stdstring-implemented/1466658#1466658|1|http://www.aristeia.com/books.html^0|0|0|0|O|E|18|4|1K|B|25|7|2F|C|2V|B|3B|4|3G|7|46|D|0|0|0|E|E|0|1|7|0|0|0|G|1|0|0|0|0|0|0|0|6|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|-4|5|C|7|1I|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1J|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1K|8|@$I|1L|J|1M|K|L]|$I|1N|J|1O|K|L]|$I|1P|J|1Q|K|L]|$I|1R|J|1S|K|L]|$I|1T|J|1U|K|L]|$I|1V|J|1W|K|L]|$I|1X|J|1Y|K|L]|$I|1Z|J|20|K|L]|$I|21|J|22|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|C|7|23|8|@]|9|@]|A|$]]|$1|N|3|O|5|F|7|24|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|25|8|@$I|26|J|27|K|L]]|9|@]|A|$]]|$1|R|3|S|5|6|7|28|8|@]|9|@$I|29|J|2A|1|2B]]|A|$]]|$1|T|3|U|5|6|7|2C|8|@]|9|@$I|2D|J|2E|1|2F]]|A|$]]|$1|V|3|W|5|6|7|2G|8|@]|9|@]|A|$]]|$1|X|3|Y|5|Z|7|2H|8|@]|9|@]|A|$]]|$1|10|3|11|5|Z|7|2I|8|@]|9|@]|A|$]]|$1|12|3|-4|5|C|7|2J|8|@]|9|@]|A|$]]|$1|13|3|14|5|F|7|2K|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|2L|8|@$I|2M|J|2N|K|L]]|9|@]|A|$]]|$1|17|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]]|18|$19|$5|1A|1B|1C|A|$1D|1E]]|1F|$5|1A|1B|1C|A|$1D|1G]]]]

A rather quick (and therefore probably incomplete) shot at answering some of the questions:

<blockquote>
 <ol>
 <li>Why is it coded as a template?</li>
 </ol>
</blockquote>

Templates provide the capability for the class functions to work on arbitrary data types. For example the <code>basic_string&lt;&gt;</code> template class can work on <code>char</code> units (which is what the <code>std::string</code> typedef does) or <code>wchar_t</code> units (<code>std::wstring</code>) or any POD type. Using something other than <code>char</code> or <code>wchar_t</code> is unusual (<code>std::vector&lt;&gt;</code> would more likely be used), but the possibility exists.

<blockquote>
 <ol start="3">
 <li>How does it do mem allocation?</li>
 </ol>
</blockquote>

This isn't specified by the standard. In fact, the <code>basic_string&lt;&gt;</code> template allows an arbitrary allocator to be used for the actual allocation of memory (but doesn't determine at what points allocations might be requested). Some implementations might store short strings in actual class members, and only allocate dynamically when the strings grow beyond a certain size. The size requested might be exactly what's need to store the string or might be a multiple of the size to allow for growth without a reallocation.

Additional information stolen from <a href="https://stackoverflow.com/questions/1466073/how-is-stdstring-implemented/1466658#1466658">another SO answer</a>:

<a href="http://www.aristeia.com/books.html" rel="nofollow noreferrer">Scott Meyer's book, Effective STL,</a> has a chapter on std::string implementations that's a decent overview of the common variations: "Item 15: Be aware of variations in string implementations".

He talks about 4 variations:

<ul>
<li>several variations on a ref-counted implementation (commonly known as copy on write) - when a string object is copied unchanged, the refcount is incremented but the actual string data is not. Both object point to the same refcounted data until one of the objects modifies it, causing a 'copy on write' of the data. The variations are in where things like the refcount, locks etc are stored.</li>
<li>a "short string optimization" implementation. In this variant, the object contains the usual pointer to data, length, size of the dynamically allocated buffer, etc. But if the string is short enough, it will use that area to hold the string instead of dynamically allocating a buffer</li>
</ul>

<blockquote>
 <ol start="4">
 <li>Why is (is not) better than mere null terminated char arrays?</li>
 </ol>
</blockquote>

One way the <code>string</code> class is better than a mere null terminated array is that the class manages the memory required, so defects involving allocation errors or overrunning the end of the allocated arrays are reduced. Another (perhaps minor) benefit is that you can store 'null' characters in the string. A drawback is that there's perhaps some overhead - especially that you pretty much have to rely on dynamic memory allocation for the string class. In most scenarios that's probably not a major issue, on some setups (embedded systems for example) it can be a problem.

blocks|key|1790799|text|为什么它被编码为模板呢？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1790800|有几个人给出了这样的答案:将std::basic_string作为模板意味着您可以同时拥有std::basic_string<char>和std::basic_string<wchar_t>。没有人解释过为什么C和C%2B%2B一开始就有多个字符类型。|unstyled|offset|length|style|CODE|1790801|C，尤其是早期版本，对于数据类型来说是极简主义的。当整数0和1工作得很好的时候，为什么有bool呢？当“字节”和“字符”都是8位时，为什么它们有不同的类型呢？|1790802|问题是，8位限制您的256个字符，这是足够的字母语言，如英语或俄语，但远远不够的日语或中文。现在我们有了Unicode和它的21位代码点。但是char不能扩展到16位或32位，因为char+=字节的假设是如此根深蒂固。因此，我们为“宽字符”提供了一个单独的类型。|1790803|但是现在我们遇到的问题是，wchar_t在Linux上是UTF-32，而在Windows上是UTF-16。为了解决这个问题，下一个版本的C%2B%2B标准将添加char16_t和char32_t类型(以及相应的字符串类型)。|1790804|entityMap^0|0|E|H|19|N|1X|Q|0|18|4|0|1Z|4|2I|4|0|D|7|24|8|2D|8|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@$E|S|F|T|G|H]|$E|U|F|V|G|H]|$E|W|F|X|G|H]]|9|@]|A|$]]|$1|I|3|J|5|D|7|Y|8|@$E|Z|F|10|G|H]]|9|@]|A|$]]|$1|K|3|L|5|D|7|11|8|@$E|12|F|13|G|H]|$E|14|F|15|G|H]]|9|@]|A|$]]|$1|M|3|N|5|D|7|16|8|@$E|17|F|18|G|H]|$E|19|F|1A|G|H]|$E|1B|F|1C|G|H]]|9|@]|A|$]]|$1|O|3|-4|5|D|7|1D|8|@]|9|@]|A|$]]]|P|$]]

<blockquote>
 Why is it coded as a template?
</blockquote>

Several people have given the answer that having <code>std::basic_string</code> be a template means that you can have both <code>std::basic_string&lt;char&gt;</code> and <code>std::basic_string&lt;wchar_t&gt;</code>. What nobody has explained is why C and C++ have multiple character types in the first place.

C, especially in its early versions, was minimalistic about data types. Why have <code>bool</code> when the integers 0 and 1 work just fine? And why have distinct types for "byte" and "character" when they're both 8 bits?

The problem is that 8 bits limits you to 256 characters, which is adequate for an alphabetic language like English or Russian, but nowhere near enough for Japanese or Chinese. And now we have Unicode with its 21-bit code points. But <code>char</code> couldn't be expanded to 16 or 32 bits because the assumption that <code>char</code> = byte was so entrenched. So we got a separate type for "wide characters".

But now we have the problem that <code>wchar_t</code> is UTF-32 on Linux but UTF-16 on Windows. And to solve that problem the next version of the C++ standard will add the <code>char16_t</code> and <code>char32_t</code> types (and corresponding string types).

I'm afraid I don't know templates (or C++, really), but I know algorithms and data structures (even some OOP! :). Anyway, to make the question a bit more precise, consider what I would like to be part of the answer (among others I don't know in advance).

<ol>
<li>Why is it coded as a template?</li>
<li>How does the template work?</li>
<li>How does it do mem allocation?</li>
<li>Why is (is not) better than mere null terminated char arrays?</li>
</ol>

How does the string class in c++ std work?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

恐怕我不知道模板(或者C++，真的)，但是我知道算法和数据结构(甚至是一些OOP！:)。无论如何，为了使这个问题更加精确，考虑一下我想成为答案的一部分(以及其他我事先不知道的问题)。为什么它被编码为模板呢？模板是如何工作的？我是怎么分配的？为什么(不是)比仅为空终止的char数组更好？

问c++ std中的字符串类是如何工作的？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问c++ std中的字符串类是如何工作的？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问c++ std中的字符串类是如何工作的？
EN