user-0 提问: 字符串常量放在静态区？

回复:
user: user-1
content: 引用 27 楼 li1983243109 的回复:[quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote] +1[/quote]  不懂就不要急着发言。

user: user-2
content: 引用 11 楼 ren0065 的回复:[quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote] +1

user: user-3
content: 引用 18 楼 sholber 的回复:[quote=引用 17 楼 micropentium6 的回复:] [quote=引用 14 楼 sholber 的回复:] [quote=引用 13 楼 ren0065 的回复:] [quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. [/quote]  U only got the literal meaning here, no to mentions the fact that it is up to the compiler to implement this so called "static storage duration" behavior on string literal, such as leaving such an "arrary" in .rodata section if ELF  Steed horse'so statement is legit in practice. In fact, C FAQ 1.32 probably has the most comprehensive explanation and by my opinion, it is way better than the c0x specification...    [/quote]  实现是靠不住的。这就是为什么我最讨厌那些用汇编输出说话的人。 话说 老习惯规定拉完屎要用纸擦，而有些人（实现）为了图方便根本不擦屁股。 你这种认识我们没有讨论的基础。bye-bye.[/quote]  LOL, by browsing your previous replies, you definitely have a history of leaving critical comments with you weird emotional pains of the illusion to be the only person on this planet who holds the truth!   It appears "屁股" and "屎" are two particular words you prefer to facilitate explaining your theory. I feel sad for you!  "实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组"  What you said here is totally by the book and without any context, it's bullshit!  实现是靠不住的。这就是为什么我最讨厌那些用汇编输出说话的人。  I am not sure if you are the author of <x86汇编语言：从实模式到保护模式> and <穿越计算机的迷雾>. If so, it would be so ironic that assembly is not your sword of "truth and justice" but the hoodoo magic trick played by the wizard!  "读过这本书的朋友，也就是你，可能会有话要说，比如发发牢骚、提几点建议；或者谈谈看法，说说感想。无论是什么，都请畅所欲言，我都绝对欢迎，即使是难听的我也不会生气。"  you spoke very sincerely there. I can't connect it with whatever you are performing here at all!  We say people get wiser with age. You seems to be the opposite!  back to this topic: the output in assembly format might not be trustworthy but it gives you the clue to explore the implementation of whatever the language spec says. Totally interpret the behavior based upon the specification, imho, is stupid. This is not a holy war, we are developers.  Anyway, please don NOT use the phrase like "shit" or "ass", they are disgusting!

user: user-1
content: 引用 13 楼 ren0065 的回复:[quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  顺便说一下，我喜欢C的原因之一就是，它是为数不多的没有被实现绑架的语言。事实上怎样和理论上应该怎样不是一回事。不要拿汇编来架空C语言。

user: user-4
content: 引用ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration[/color] and length just sufficient to contain the sequence. 这只说明了 char* xxx = "xxx"; 的存在方式. char xxx[10] = "xxx"; 是一个赋值的过程, 请见 6.7.9

user: user-1
content: 引用 17 楼 micropentium6 的回复:[quote=引用 14 楼 sholber 的回复:] [quote=引用 13 楼 ren0065 的回复:] [quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. [/quote]  U only got the literal meaning here, no to mentions the fact that it is up to the compiler to implement this so called "static storage duration" behavior on string literal, such as leaving such an "arrary" in .rodata section if ELF  Steed horse'so statement is legit in practice. In fact, C FAQ 1.32 probably has the most comprehensive explanation and by my opinion, it is way better than the c0x specification...    [/quote]  实现是靠不住的。这就是为什么我最讨厌那些用汇编输出说话的人。 话说 老习惯规定拉完屎要用纸擦，而有些人（实现）为了图方便根本不擦屁股。 你这种认识我们没有讨论的基础。bye-bye.

user: user-3
content: 引用 14 楼 sholber 的回复:[quote=引用 13 楼 ren0065 的回复:] [quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. [/quote]  U only got the literal meaning here, no to mentions the fact that it is up to the compiler to implement this so called "static storage duration" behavior on string literal, such as leaving such an "arrary" in .rodata section if ELF  Steed horse'so statement is legit in practice. In fact, C FAQ 1.32 probably has the most comprehensive explanation and by my opinion, it is way better than the c0x specification...

user: user-5
content: 程序未运行的时候，字符串this is a test在可执行文件中。运行该可执行文件，字符串this is a test被加载到内存的一个静态只读存储区，假设该地址为A。当main函数被调用时，array在堆栈上分配内存，然后从A处拷贝"this is a test"到array，此时array便存放了该字符串的一个副本

user: user-6
content: 引用 1 楼 Lion1946 的回复:char array[]         栈区 "this is a test "    常量区 说到点上了！  int main(int argc, char *argv[]) {     char array[]=" this is a test ";     return 0; }  生成的汇编类似下面      .file   "foo.c"     .section    .rodata .LC0:     .string " this is a test "     .text     .p2align 4,,15 .globl main     .type   main, @function main:     leal    4(%esp), %ecx     andl    $-16, %esp     pushl   -4(%ecx)     pushl   %ebp     movl    %esp, %ebp     pushl   %ecx     subl    $32, %esp     movl    .LC0, %eax     movl    %eax, -21(%ebp)     movl    .LC0+4, %eax     movl    %eax, -17(%ebp)     movl    .LC0+8, %eax     movl    %eax, -13(%ebp)     movl    .LC0+12, %eax     movl    %eax, -9(%ebp)     movzbl  .LC0+16, %eax     movb    %al, -5(%ebp)     movl    $0, %eax     addl    $32, %esp     popl    %ecx     popl    %ebp     leal    -4(%ecx), %esp     ret     .size   main, .-main     .ident  "GCC: (GNU) 4.2.1 20070719  [FreeBSD]"

user: user-1
content: 引用 13 楼 ren0065 的回复:[quote=引用 12 楼 sholber 的回复:] [quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!![/quote]  ISO/IEC 9899:201x Committee Draft — April 12, 2011 N1570 6.4.5 String literals 6 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence.

user: user-4
content: 引用 12 楼 sholber 的回复:[quote=引用 11 楼 ren0065 的回复:] [quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。[/quote]  原文出处链接请求!!!!

user: user-1
content: 引用 11 楼 ren0065 的回复:[quote=引用 7 楼 sholber 的回复:] [quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云[/quote]  这是C标准上的原话。你看不懂，说明你还需要努力加强科学文化知识的学习呀。

user: user-4
content: 引用 7 楼 sholber 的回复:[quote=引用 5 楼 steedhorse 的回复:] 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。[/quote]  不知所云

user: user-7
content: 常量存放在常量区。

user: user-1
content: 引用 3 楼 qq_16650397 的回复:char array[]   实际上是系统自动申请内存给array[], "this is a test "    放在字符静态常量区 不知所云。 什么叫自动申请内存 什么叫字符静态常量区

user: user-8
content: char array[]   实际上是系统自动申请内存给array[], "this is a test "    放在字符静态常量区

user: user-1
content: 引用 5 楼 steedhorse 的回复:这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。  简单的问题，被你罗里罗索，不知所云。 实际上就一句话，在编译期间，串字面值被用于初始化一个静态数组。

user: user-1
content: 引用 1 楼 Lion1946 的回复:char array[]         栈区 "this is a test "    常量区  不知所云。

user: user-9
content: 。。。。 看一下编译后的结果就知道，否则容易盲人摸象

user: user-10
content: 这几句话涉及了不少问题。 我觉得首先搞清"this is a test"是个字符串字面量（string literal）；而array是个函数局部的数组（长度为字符串的长度加1）。 然后要了解： char array[]=" this is a test "; 跟 const char* p = "this is a test" 之间的不同。 前者确实存在一个拷贝过程，而后者只是用一个指针指向了常量区那个字面量的首地址。  严格讲字符串字面量存储在“常量区”，“静态区”通常是指存储可变的全局变量和静态局部变量的地方。  至于“程序未运行的时候就已经分配好内存了”也有点笼统，具体来讲是可执行文件编译连接好之后，这些常量区的内容和存储位置信息就已经计算好了，这些信息会保存在可执行文件中。将来程序加载时直接读进内存，而不像函数的局部变量，要待程序执行之后随着函数的层层调用（和返回）在栈上动态分配。