blocks|key|312298|text|一种常见的技术是将字符串放在“只读数据”部分中，该部分以只读的形式映射到进程空间(这就是您不能更改它的原因)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|312299|它确实因平台而异。例如，较简单的芯片架构可能不支持只读存储器段，因此数据段将是可写的。|312300|而不是试图找出一个技巧，使字符串文字可变(它将高度依赖于您的平台，并可能随着时间的推移而变化)，只需使用数组：|312301|char+foo[]+=+"...";|code-block|syntax|javascript|312302|编译器将安排数组从文字初始化，您可以修改数组。|312303|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

A common technique is for string literals to be put in &quot;read-only-data&quot; section which gets mapped into the process space as read-only (which is why you can't change it).
It does vary by platform. For example, simpler chip architectures may not support read-only memory segments so the data segment will be writable.
Rather than try to figure out a trick to make string literals changeable (it will be highly dependent on your platform and could change over time), just use arrays:
<pre><code>char foo[] = &quot;...&quot;;
</code></pre>
The compiler will arrange for the array to get initialized from the literal and you can modify the array.

blocks|key|3265451|text|这取决于您的executable的format。考虑这一点的一种方法是，如果你正在进行汇编编程，你可能会把字符串文字放在汇编程序的数据段中。你的C编译器会做类似的事情，但这完全取决于你的二进制文件是为什么系统编译的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3265452|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Executable|1|http://en.wikipedia.org/wiki/Comparison_of_executable_file_formats^0|6|A|0|H|6|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

It depends on the <a href="http://en.wikipedia.org/wiki/Comparison_of_executable_file_formats" rel="nofollow noreferrer">format</a> of your <a href="http://en.wikipedia.org/wiki/Executable" rel="nofollow noreferrer">executable</a>. One way to think about it is that if you were assembly programming, you might put string literals in the data segment of your assembly program. Your C compiler does something like that, but it all depends on what system you're binary is being compiled for.

blocks|key|309313|text|这个问题没有一个答案。C和C%2B%2B标准只是说字符串文字具有静态存储持续时间，任何修改它们的尝试都会产生未定义的行为，并且具有相同内容的多个字符串文字可能共享相同的存储空间，也可能不共享相同的存储空间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|309314|根据您正在为其编写的系统以及它所使用的可执行文件格式的功能，它们可能与程序代码一起存储在文本段中，或者它们可能有一个单独的段用于初始化数据。|309315|根据平台的不同，确定细节也会有所不同--最有可能包括的工具可以告诉您它放在哪里。有些甚至可以让你控制这样的细节，如果你想要的话(例如gnu+ld允许你提供一个脚本来告诉你如何对数据、代码等进行分组)。|309316|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

There is no one answer to this. The C and C++ standards just say that string literals have static storage duration, any attempt at modifying them gives undefined behavior, and multiple string literals with the same contents may or may not share the same storage.

Depending on the system you're writing for, and the capabilities of the executable file format it uses, they may be stored along with the program code in the text segment, or they may have a separate segment for initialized data.

Determining the details will vary depending on the platform as well -- most probably include tools that can tell you where it's putting it. Some will even give you control over details like that, if you want it (e.g. gnu ld allows you to supply a script to tell it all about how to group data, code, etc.)

blocks|key|314405|text|gcc创建了一个.rodata部分，该部分被映射到地址空间中的“某处”并被标记为只读，|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|314406|Visual+C%2B%2B+(cl.exe)为同样的目的制作了一个.rdata节。|314407|您可以查看dumpbin或objdump+(在Linux上)的输出，以查看可执行文件的各个部分。|314408|例如。|314409|>dumpbin+vec1.exe
Microsoft+(R)+COFF/PE+Dumper+Version+8.00.50727.762
Copyright+(C)+Microsoft+Corporation.++All+rights+reserved.


Dump+of+file+vec1.exe

File+Type:+EXECUTABLE+IMAGE

++Summary

++++++++4000+.data
++++++++5000+.rdata++<--+here+are+strings+and+other+read-only+stuff.
+++++++14000+.text|code-block|syntax|javascript|314410|entityMap^0|8|7|0|C|6|U|6|0|5|7|D|7|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|15|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|16|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|R|$]]

gcc makes a <code>.rodata</code> section that gets mapped "somewhere" in address space and is marked read only,

Visual C++ (<code>cl.exe</code>) makes a <code>.rdata</code> section for the same purpose.

You can look at the output from <code>dumpbin</code> or <code>objdump</code> (on Linux) to see the sections of your executable.

E.g.

<pre><code>&gt;dumpbin vec1.exe
Microsoft (R) COFF/PE Dumper Version 8.00.50727.762
Copyright (C) Microsoft Corporation. All rights reserved.


Dump of file vec1.exe

File Type: EXECUTABLE IMAGE

 Summary

 4000 .data
 5000 .rdata &lt;-- here are strings and other read-only stuff.
 14000 .text
</code></pre>

blocks|key|314450|text|仅供参考，只需备份其他答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|314451|标准：ISO/IEC+14882:2003说：|offset|length|314452|314453|+2.13。字符串文字|blockquote|style|BOLD|314454|314455|314456|314457|...An普通字符串文字具有类型“n+const+char+of+n+const+char”和静态存储持续时间(3.7)|ordered-list-item|CODE|314458|是否所有字符串文字都是不同的(即存储在不重叠的对象中)由实现定义。尝试修改字符串文字的效果未定义。|314459|314460|entityMap|0|LINK|mutability|MUTABLE|url|http://www.iso.org/iso/catalogue_detail.htm?csnumber=38110^0|0|3|I|0|0|0|1|A|0|0|0|0|H|C|X|C|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|F|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|19|8|@$D|1A|E|1B|J|K]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1F|8|@$D|1G|E|1H|J|R]|$D|1I|E|1J|J|R]]|9|@]|A|$]]|$1|S|3|T|5|Q|7|1K|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]]]

FYI, just backing up the other answers: 

The standard: <a href="http://www.iso.org/iso/catalogue_detail.htm?csnumber=38110" rel="noreferrer">ISO/IEC 14882:2003</a> says:

<blockquote>
 2.13. String literals
 
 <ol>
 <li>[...]An ordinary string literal has type “array of <code>n const char</code>” and
 static storage duration (3.7)</li>
 <li>Whether all string literals are distinct (that is, are stored in
 nonoverlapping objects) is
 implementation- defined. The effect of
 attempting to modify a string literal
 is undefined.</li>
 </ol>
</blockquote>

blocks|key|311568|text|字符串字面值经常分配给只读内存，这使得它们是不可变的。然而，在一些编译器中，修改是可能的“聪明技巧”..And的聪明技巧是通过“使用字符指针指向内存”一些编译器，可能不允许this..Here是演示|type|unstyled|depth|inlineStyleRanges|entityRanges|data|311569|char+*tabHeader+=+"Sound";
*tabHeader+=+'L';
printf("%25s\n",tabHeader);+//+Displays+"Lound"|code-block|syntax|javascript|311570|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

String literals are frequently allocated to the read-only memory, making them immutable. However, in some compilers modification is possible by a "smart trick"..And the smart trick is by "using character pointer pointing to memory"..remember some compilers, may not allow this..Here is demo 

<pre><code>char *tabHeader = "Sound";
*tabHeader = 'L';
printf("%s\n",tabHeader); // Displays "Lound"
</code></pre>

blocks|key|311591|text|为什么我不应该尝试更改它？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|311592|因为它是未定义的行为。引用自C99+N1256+draft+6.7.8/32+"Initialization"|311593|311594|示例8:声明|blockquote|311595|311596|char+s[]+=+"abc"，t3+=+"abc"；|311597|定义“纯”字符数组对象s和t，它们的元素是用字符串文字初始化的。|CODE|311598|此声明与|311599|t[]+s[]+={+'a'，'b'，'c'，'\0‘}，char+={+'a'，'b'，'c’}；|311600|数组的内容是可修改的。另一方面，声明|311601|char+*p+=+"abc"；|311602|定义类型为"pointer+to+char“的数组，并将其初始化为指向一个类型为"array+char”、长度为4的对象，该对象的元素由字符串文字初始化。如果试图使用p修改数组的内容，则行为是未定义的。|311603|311604|他们会去哪里？|311605|GCC+4.8+x86-64+ELF+Ubuntu+14.04：|311606|目标文件的|311607|char+s[]：stack|unordered-list-item|311608|char+*s：|311609|.rodata段转储目标文件的.text段的同一段，该段具有读取和执行权限，但没有Write|311610|311611|权限|311612|程序：|311613|#include+<stdio.h>

int+main()+{
++++char+*s+=+"abc";
++++printf("%25s\n",+s);
++++return+0;
}|code-block|syntax|javascript|311614|编译和反编译：|311615|gcc+-ggdb+-std=c99+-c+main.c
objdump+-Sr+main.o|311616|输出包含：|311617|+char+*s+=+"abc";
8:++48+c7+45+f8+00+00+00++++movq+++$0x0,-0x8(%25rbp)
f:++00+
++++++++c:+R_X86_64_32S+.rodata|311618|因此，字符串存储在.rodata部分中。|311619|然后：|311620|readelf+-l+a.out|311621|包含(简化)：|311622|Program+Headers:
++Type+++++++++++Offset+++++++++++++VirtAddr+++++++++++PhysAddr
+++++++++++++++++FileSiz++++++++++++MemSiz++++++++++++++Flags++Align
++++++[Requesting+program+interpreter:+/lib64/ld-linux-x86-64.so.2]
++LOAD+++++++++++0x0000000000000000+0x0000000000400000+0x0000000000400000
+++++++++++++++++0x0000000000000704+0x0000000000000704++R+E++++200000

+Section+to+Segment+mapping:
++Segment+Sections...
+++02+++++.text+.rodata|311623|这意味着默认的链接器脚本将.text和.rodata都转储到可以执行但不能修改的段(Flags+=+R+E)中。试图修改这样的段会导致Linux中的段错误。|311624|如果我们对char[]执行同样的操作|311625|+char+s[]+=+"abc";|311626|我们得到：|311627|17:+++c7+45+f0+61+62+63+00++++movl+++$0x636261,-0x10(%25rbp)|311628|所以它被存储在堆栈中(相对于%25rbp)，我们当然可以修改它。|311629|entityMap|0|LINK|mutability|MUTABLE|url|http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf^0|0|D|0|U|P|E|F|0|0|0|0|0|0|B|1|D|1|0|0|0|0|0|2B|1|0|0|0|7|0|0|0|0|8|0|0|7|1|0|7|F|5|1|0|0|0|0|0|0|0|0|9|7|0|0|0|0|0|D|5|J|7|16|B|0|5|6|0|0|0|0|E|4|0^^$0|@$1|2|3|4|5|6|7|2R|8|@$9|2S|A|2T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|2U|8|@$9|2V|A|2W|B|C]]|D|@$9|2X|A|2Y|1|2Z]]|E|$]]|$1|H|3|-4|5|6|7|30|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|31|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|32|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|33|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|34|8|@$9|35|A|36|B|Q]|$9|37|A|38|B|Q]]|D|@]|E|$]]|$1|R|3|S|5|6|7|39|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|3A|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|3B|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|3C|8|@]|D|@]|E|$]]|$1|Z|3|10|5|6|7|3D|8|@$9|3E|A|3F|B|Q]]|D|@]|E|$]]|$1|11|3|-4|5|6|7|3G|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|3H|8|@$9|3I|A|3J|B|C]]|D|@]|E|$]]|$1|14|3|15|5|6|7|3K|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|3L|8|@]|D|@]|E|$]]|$1|18|3|19|5|1A|7|3M|8|@$9|3N|A|3O|B|Q]]|D|@]|E|$]]|$1|1B|3|1C|5|1A|7|3P|8|@$9|3Q|A|3R|B|Q]]|D|@]|E|$]]|$1|1D|3|1E|5|1A|7|3S|8|@$9|3T|A|3U|B|Q]|$9|3V|A|3W|B|Q]]|D|@]|E|$]]|$1|1F|3|-4|5|6|7|3X|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|3Y|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|3Z|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|1M|7|40|8|@]|D|@]|E|$1N|1O]]|$1|1P|3|1Q|5|6|7|41|8|@]|D|@]|E|$]]|$1|1R|3|1S|5|1M|7|42|8|@]|D|@]|E|$1N|1O]]|$1|1T|3|1U|5|6|7|43|8|@]|D|@]|E|$]]|$1|1V|3|1W|5|1M|7|44|8|@]|D|@]|E|$1N|1O]]|$1|1X|3|1Y|5|6|7|45|8|@$9|46|A|47|B|Q]]|D|@]|E|$]]|$1|1Z|3|20|5|6|7|48|8|@]|D|@]|E|$]]|$1|21|3|22|5|1M|7|49|8|@]|D|@]|E|$1N|1O]]|$1|23|3|24|5|6|7|4A|8|@]|D|@]|E|$]]|$1|25|3|26|5|1M|7|4B|8|@]|D|@]|E|$1N|1O]]|$1|27|3|28|5|6|7|4C|8|@$9|4D|A|4E|B|Q]|$9|4F|A|4G|B|Q]|$9|4H|A|4I|B|Q]]|D|@]|E|$]]|$1|29|3|2A|5|6|7|4J|8|@$9|4K|A|4L|B|Q]]|D|@]|E|$]]|$1|2B|3|2C|5|1M|7|4M|8|@]|D|@]|E|$1N|1O]]|$1|2D|3|2E|5|6|7|4N|8|@]|D|@]|E|$]]|$1|2F|3|2G|5|1M|7|4O|8|@]|D|@]|E|$1N|1O]]|$1|2H|3|2I|5|6|7|4P|8|@$9|4Q|A|4R|B|Q]]|D|@]|E|$]]|$1|2J|3|-4|5|6|7|4S|8|@]|D|@]|E|$]]]|2K|$2L|$5|2M|2N|2O|E|$2P|2Q]]]]

Why should I not try to alter it?
Because it is undefined behavior. Quote from <a href="http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf" rel="nofollow noreferrer">C99 N1256 draft</a> 6.7.8/32 &quot;Initialization&quot;:
<blockquote>
EXAMPLE 8: The declaration
<pre><code>char s[] = &quot;abc&quot;, t[3] = &quot;abc&quot;;
</code></pre>
defines &quot;plain&quot; char array objects <code>s</code> and <code>t</code> whose elements are initialized with character string literals.
This declaration is identical to
<pre><code>char s[] = { 'a', 'b', 'c', '\0' },
t[] = { 'a', 'b', 'c' };
</code></pre>
The contents of the arrays are modifiable. On the other hand, the declaration
<pre><code>char *p = &quot;abc&quot;;
</code></pre>
defines <code>p</code> with type &quot;pointer to char&quot; and initializes it to point to an object with type &quot;array of const char&quot; with length 4 whose elements are initialized with a character string literal. If an attempt is made to use <code>p</code> to modify the contents of the array, the behavior is undefined.
</blockquote>
Where do they go?
GCC 4.8 x86-64 ELF Ubuntu 14.04:
<ul>
<li><code>char s[]</code>: stack</li>
<li><code>char *s</code>:
<ul>
<li><code>.rodata</code> section of the object file</li>
<li>the same segment where the <code>.text</code> section of the object file gets dumped, which has Read and Exec permissions, but not Write</li>
</ul>
</li>
</ul>
Program:
<pre><code>#include &lt;stdio.h&gt;

int main() {
 char *s = &quot;abc&quot;;
 printf(&quot;%s\n&quot;, s);
 return 0;
}
</code></pre>
Compile and decompile:
<pre><code>gcc -ggdb -std=c99 -c main.c
objdump -Sr main.o
</code></pre>
Output contains:
<pre><code> char *s = &quot;abc&quot;;
8: 48 c7 45 f8 00 00 00 movq $0x0,-0x8(%rbp)
f: 00 
 c: R_X86_64_32S .rodata
</code></pre>
So the string is stored in the <code>.rodata</code> section.
Then:
<pre><code>readelf -l a.out
</code></pre>
Contains (simplified):
<pre><code>Program Headers:
 Type Offset VirtAddr PhysAddr
 FileSiz MemSiz Flags Align
 [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
 LOAD 0x0000000000000000 0x0000000000400000 0x0000000000400000
 0x0000000000000704 0x0000000000000704 R E 200000

 Section to Segment mapping:
 Segment Sections...
 02 .text .rodata
</code></pre>
This means that the default linker script dumps both <code>.text</code> and <code>.rodata</code> into a segment that can be executed but not modified (<code>Flags = R E</code>). Attempting to modify such a segment leads to a segfault in Linux.
If we do the same for <code>char[]</code>:
<pre><code> char s[] = &quot;abc&quot;;
</code></pre>
we obtain:
<pre><code>17: c7 45 f0 61 62 63 00 movl $0x636261,-0x10(%rbp)
</code></pre>
so it gets stored in the stack (relative to <code>%rbp</code>), and we can of course modify it.

blocks|key|3052040|text|由于不同的编译器可能会有所不同，因此最好的方法是过滤对象转储以查找搜索到的字符串文字：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3052041|objdump+-s+main.o+%7C+grep+-B+1+str|code-block|syntax|javascript|3052042|其中-s强制objdump显示所有部分的完整内容，main.o是目标文件，-B+1强制grep在匹配之前打印一行(以便您可以看到部分名称)，str是您要搜索的字符串文字。|offset|length|style|CODE|3052043|在Windows机上有一个用main声明的变量，比如|3052044|char+*c+=+"whatever";|3052045|正在运行|3052046|objdump+-s+main.o+%7C+grep+-B+1+whatever|3052047|返回|3052048|Contents+of+section+.rdata:
+0000+77686174+65766572+00000000+++++++++++whatever....|3052049|entityMap^0|0|0|2|2|6|7|P|6|11|4|17|4|1Y|3|0|E|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]|$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1F|8|@$I|1G|J|1H|K|L]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|Z|$]]

As this might differ from compiler to compiler, the best way is to filter an object dump for the searched string literal:

<pre><code>objdump -s main.o | grep -B 1 str
</code></pre>

where <code>-s</code> forces <code>objdump</code> to display the full contents of all sections, <code>main.o</code> is the object file, <code>-B 1</code> forces <code>grep</code> to also print one line before the match (so that you can see the section name) and <code>str</code> is the string literal you're searching for.

With gcc on a Windows machine, and one variable declared in <code>main</code> like

<pre><code>char *c = "whatever";
</code></pre>

running

<pre><code>objdump -s main.o | grep -B 1 whatever
</code></pre>

returns

<pre><code>Contents of section .rdata:
 0000 77686174 65766572 00000000 whatever....
</code></pre>

I am interested in where string literals get allocated/stored.

I did find one intriguing answer <a href="https://stackoverflow.com/questions/51592/is-there-a-need-to-destroy-char-string-or-char-new-char6/51607#51607">here</a>, saying:

<blockquote>
 Defining a string inline actually embeds the data in the program itself and cannot be changed (some compilers allow this by a smart trick, don't bother).
</blockquote>

But, it had to do with C++, not to mention that it says not to bother.

I am bothering. =D

So my question is where and how is my string literal kept? Why should I not try to alter it? Does the implementation vary by platform? Does anyone care to elaborate on the "smart trick?"

String literals: Where do they go?

编译器

Windows

Ubuntu

Linux

我感兴趣的是字符串字面值的分配/存储位置。我确实找到了一个耐人寻味的答案，他说：定义字符串内联的实际上将数据嵌入到程序本身中，并且不能更改(一些编译器通过一个聪明的技巧实现了这一点，不必费心)。但是，它与C++有关，更不用说它说不用麻烦了。我很烦人。=D所以我的问题是，我的字符串应该放在哪里，如何保存？为什么我不应该尝...

问字符串字面值:它们会去哪里？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问字符串字面值:它们会去哪里？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问字符串字面值:它们会去哪里？
EN