在C语言中,可以在这样的声明中使用字符串文字:
char s[] = "hello";
或像这样:
char *s = "hello";
那么区别是什么呢?我想知道在编译和运行时在存储持续时间方面实际发生了什么。
在C语言中,可以在这样的声明中使用字符串文字:
char s[] = "hello";
或像这样:
char *s = "hello";
那么区别是什么呢?我想知道在编译和运行时在存储持续时间方面实际发生了什么。
Answers:
区别在于
char *s = "Hello world";
将被放置"Hello world"
在存储器的只读部分中,并使其s
指向该存储器的任何写操作都是非法的。
这样做时:
char s[] = "Hello world";
将文字字符串放入只读内存中,并将该字符串复制到堆栈上新分配的内存中。因此使
s[0] = 'J';
法律。
"Hello world"
在两个示例中,文字字符串都位于“内存的只读部分”中。带有数组的示例指向那里,带有数组的示例将字符复制到数组元素。
char msg[] = "hello, world!";
字符串的文件进行了干净的编译,该文件最终位于初始化的数据部分中。当声明char * const
结束于只读数据部分时。gcc-4.5.3
首先,在函数参数中,它们是完全等效的:
void foo(char *x);
void foo(char x[]); // exactly the same in all respects
在其他情况下,char *
分配一个指针,而char []
分配一个数组。您问在前一种情况下字符串会去哪里?编译器秘密分配一个静态匿名数组来保存字符串文字。所以:
char *x = "Foo";
// is approximately equivalent to:
static const char __secret_anonymous_array[] = "Foo";
char *x = (char *) __secret_anonymous_array;
请注意,您绝不能尝试通过此指针修改此匿名数组的内容;效果是不确定的(通常意味着崩溃):
x[1] = 'O'; // BAD. DON'T DO THIS.
使用数组语法直接将其分配到新的内存中。因此修改是安全的:
char x[] = "Foo";
x[1] = 'O'; // No problem.
但是,该数组的生存时间只有其包含范围的范围,因此,如果您在函数中执行此操作,请不要返回或泄漏指向该数组的指针-使用strdup()
或类似的方法进行复制。如果数组是在全局范围内分配的,那当然没问题。
此声明:
char s[] = "hello";
创建一个对象- char
大小为6 的数组,称为s
,使用values初始化'h', 'e', 'l', 'l', 'o', '\0'
。该数组在内存中的分配位置以及生存期取决于声明出现的位置。如果声明在函数内,则声明将一直存在,直到声明所在的块的末尾为止,并且几乎可以肯定地将其分配在堆栈上。如果它在函数外部,则可能会存储在“初始化的数据段”中,该段会在程序运行时从可执行文件加载到可写内存中。
另一方面,此声明:
char *s ="hello";
创建两个对象:
char
包含values 'h', 'e', 'l', 'l', 'o', '\0'
,该数组没有名称,并且具有静态存储持续时间(意味着它在程序的整个生命周期内都有效);和s
,使用该未命名只读数组中第一个字符的位置进行初始化。未命名的只读数组通常位于程序的“文本”段中,这意味着它与代码本身一起从磁盘加载到只读存储器中。s
指针变量在内存中的位置取决于声明出现的位置(就像第一个示例一样)。
char s[] = "hello"
情况下,"hello"
只是一个初始化程序,告诉编译器应如何初始化数组。它可能会或可能不会在文本段中产生相应的字符串-例如,如果s
具有静态存储持续时间,则很可能唯一的实例"hello"
将在初始化的数据段中-对象s
本身。即使s
具有自动存储期限,也可以通过一系列文字存储而不是副本(例如movl $1819043176, -6(%ebp); movw $111, -2(%ebp)
)来初始化它。
char s[] = "Hello world";
将文字字符串放入只读内存中,并将该字符串复制到堆栈上新分配的内存中。但是,您的答案仅涉及放在只读存储器中的原义字符串,而跳过句子的第二部分:copies the string to newly allocated memory on the stack
。因此,由于未指定第二部分,您的答案是否不完整?
char s[] = "Hellow world";
只是一个初始化程序,不一定存储为单独的只读副本。如果s
具有静态存储持续时间,则字符串的唯一副本很可能位于的位置的读写段中s
,即使没有,编译器也可以选择使用立即加载指令或类似指令初始化数组,而不是复制来自只读字符串。关键是在这种情况下,初始化程序字符串本身不存在运行时。
给出声明
char *s0 = "hello world";
char s1[] = "hello world";
假设以下假设内存映射:
0x01 0x02 0x03 0x04 0x00008000:'h''e''l''l' 0x00008004:'o'''w''o' 0x00008008:'r''l''d'0x00 ... s0:0x00010000:0x00 0x00 0x80 0x00 s1:0x00010004:'h''e''l''l' 0x00010008:'o'''w''o' 0x0001000C:'r''l''d'0x00
字符串文字"hello world"
是具有12个元素的数组char
(const char
在C ++中),具有静态存储持续时间,这意味着它的内存在程序启动时分配,并保持分配状态,直到程序终止。尝试修改字符串文字的内容会调用未定义的行为。
线
char *s0 = "hello world";
定义s0
为指向char
具有自动存储持续时间的指针(意味着该变量s0
仅在声明它的作用域中存在),并将字符串文字的地址(0x00008000
在此示例中)复制到该地址。注意,因为s0
指向一个字符串字面量,它不应该被用来作为一个参数,将试图修改它的任何功能(如strtok()
,strcat()
,strcpy()
,等)。
线
char s1[] = "hello world";
定义s1
为具有12个元素的数组char
(长度从字符串文字中获取)并具有自动存储持续时间,并将文字内容复制到该数组中。从内存映射中可以看到,我们有两个字符串副本"hello world"
;区别在于您可以修改中包含的字符串s1
。
s0
而s1
在大多数情况下可以互换; 这里是例外:
sizeof s0 == sizeof (char*)
sizeof s1 == 12
type of &s0 == char **
type of &s1 == char (*)[12] // pointer to a 12-element array of char
您可以重新分配变量s0
以指向其他字符串文字或另一个变量。您不能重新分配变量s1
以指向其他数组。
C99 N1256草案
字符串文字有两种不同的用法:
初始化char[]
:
char c[] = "abc";
这是“更多的魔术”,在6.7.8 / 14“初始化”中进行了描述:
字符类型数组可以由字符串文字初始化,并可选地用大括号括起来。字符串文字的连续字符(如果有空间或数组大小未知,则包括终止空字符)将初始化数组的元素。
因此,这只是以下方面的捷径:
char c[] = {'a', 'b', 'c', '\0'};
像任何其他常规数组一样,c
可以进行修改。
其他任何地方:都会产生:
所以当你写:
char *c = "abc";
这类似于:
/* __unnamed is magic because modifying it gives UB. */
static char __unnamed[] = "abc";
char *c = __unnamed;
请注意,从char[]
到的隐式强制转换char *
始终是合法的。
然后,如果您修改c[0]
,那么您还修改了__unnamed
UB。
在6.4.5“字符串文字”中有记录:
5在转换阶段7中,一个或多个字符串文字产生的每个多字节字符序列将附加一个零值的字节或代码。然后,多字节字符序列用于初始化一个足以包含该序列的静态存储持续时间和长度数组。对于字符串文字,数组元素的类型为char,并使用多字节字符序列的各个字节进行初始化[...]
6如果这些数组的元素具有适当的值,则不确定这些数组是否不同。如果程序尝试修改这样的数组,则行为是不确定的。
6.7.8 / 32“初始化”给出了一个直接的示例:
例8:声明
char s[] = "abc", t[3] = "abc";
定义“普通” char数组对象
s
,t
其元素用字符串文字初始化。此声明与
char s[] = { 'a', 'b', 'c', '\0' }, t[] = { 'a', 'b', 'c' };
数组的内容是可修改的。另一方面,声明
char *p = "abc";
定义
p
类型为“ char的指针”并将其初始化为长度为4的“ char数组”类型的对象,该对象的元素使用字符串文字进行初始化。如果试图使用它p
来修改数组的内容,则该行为是不确定的。
GCC 4.8 x86-64 ELF实施
程序:
#include <stdio.h>
int main(void) {
char *s = "abc";
printf("%s\n", s);
return 0;
}
编译和反编译:
gcc -ggdb -std=c99 -c main.c
objdump -Sr main.o
输出包含:
char *s = "abc";
8: 48 c7 45 f8 00 00 00 movq $0x0,-0x8(%rbp)
f: 00
c: R_X86_64_32S .rodata
结论:GCC将char*
其存储在.rodata
部分中,而不是在中.text
。
但是请注意,默认的链接程序脚本将.rodata
和.text
放在同一段中,该段具有执行但没有写权限。这可以通过以下方式观察到:
readelf -l a.out
其中包含:
Section to Segment mapping:
Segment Sections...
02 .text .rodata
如果我们这样做char[]
:
char s[] = "abc";
我们获得:
17: c7 45 f0 61 62 63 00 movl $0x636261,-0x10(%rbp)
因此它存储在堆栈中(相对于%rbp
)。
char s[] = "hello";
声明s
是一个阵列的char
哪个是长到足以保持初始化(5个+ 1 char
S)和由给定字符串文字的成员复制到阵列初始化数组。
char *s = "hello";
声明s
是一个或多个(在这种情况下为多个)char
s 的指针,并将其直接指向包含literal的固定(只读)位置"hello"
。
s
都指向const char
。
char s[] = "Hello world";
这里s
是一个字符数组,如果我们愿意,可以覆盖它们。
char *s = "hello";
字符串文字用于在该指针s
指向的内存中的某个位置创建这些字符块。我们可以通过更改它来重新分配它所指向的对象,但是只要它指向字符串文字,就不能更改它所指向的字符块。
另外,请考虑一下,出于只读目的,两者的使用是相同的,因此可以通过[]
或编制索引来访问char *(<var> + <index>)
:
printf("%c", x[1]); //Prints r
和:
printf("%c", *(x + 1)); //Prints r
显然,如果您尝试这样做
*(x + 1) = 'a';
当您尝试访问只读内存时,您可能会遇到分段错误。
x[1] = 'a';
(当然取决于平台)。
char *str = "Hello";
上面的设置str指向文本值“ Hello”,该值在程序的二进制映像中进行了硬编码,并在内存中标记为只读,这意味着对该String文本进行的任何更改都是非法的,并且会引发分段错误。
char str[] = "Hello";
将字符串复制到堆栈上新分配的内存中。因此,允许对其进行任何更改都是合法的。
means str[0] = 'M';
将str更改为“ Mello”。
有关更多详细信息,请经历类似的问题:
根据这里的评论,应该显而易见的是:char * s =“ hello”; 这是一个坏主意,应在非常狭窄的范围内使用。
这可能是一个很好的机会,指出“常量正确性”是“好事”。无论何时何地,都可以使用“ const”关键字来保护您的代码,以防“松弛”的调用者或程序员,这通常在指针起作用时最“松弛”。
足够的情节剧,这是在用“ const”修饰指针时可以实现的目标。(注意:必须从右到左读取指针声明。)以下是在使用指针时保护自己的3种不同方式:
const DBJ* p means "p points to a DBJ that is const"
—也就是说,不能通过p更改DBJ对象。
DBJ* const p means "p is a const pointer to a DBJ"
—也就是说,可以通过p更改DBJ对象,但是不能更改指针p本身。
const DBJ* const p means "p is a const pointer to a const DBJ"
—也就是说,您不能更改指针p本身,也不能通过p更改DBJ对象。
与未遂常数突变有关的错误是在编译时捕获的。const没有运行时空间或速度损失。
(当然,假设您正在使用C ++编译器?)
--DBJ