这些答案大部分都是正确的，但为了更清楚一点……

人们所说的“只读内存”是ASM术语中的文本段。它是内存中加载指令的同一个地方。出于安全等明显的原因，这是只读的。当创建一个初始化为字符串的char*时，字符串数据被编译到文本段中，程序初始化指向文本段的指针。所以如果你想改变它，就死定了。段错误。

当作为数组编写时，编译器将初始化的字符串数据放在数据段中，这与全局变量等存在的位置相同。这个内存是可变的，因为数据段中没有指令。这一次，当编译器初始化字符数组(仍然只是一个char*)时，它指向的是数据段而不是文本段，您可以在运行时安全地更改文本段。

首先，str是一个指向"string"的指针。编译器允许将字符串字面量放在内存中不能写入，但只能读取的地方。(这真的应该触发一个警告，因为你将一个const char *分配给一个char *。你是禁用了警告，还是忽略了它们?)

第二，你在创建一个数组，它是你可以完全访问的内存，并用"string"初始化它。您正在创建一个字符[7](六个用于字母，一个用于结尾的'\0')，您可以对它做任何您喜欢的事情。

要理解这个错误或问题，您应该首先了解指针和数组的差异b/w 所以在这里，我首先要解释一下它们的区别

字符串数组

 char strarray[] = "hello";

在存储器数组中存储的是连续存储器单元，存储为[h][e][l][l][o][\0] =>[]是1个char字节大小的存储器单元，而这个连续存储器单元可以通过名为strarray的名称在这里访问。这里string数组strarray本身包含初始化的所有字符串。在这种情况下，"hello" 因此，我们可以通过访问每个字符的索引值来轻松地更改其内存内容

`strarray[0]='m'` it access character at index 0 which is 'h'in strarray

它的值变成了m所以strarray的值变成了mello;

这里需要注意的一点是，我们可以通过一个字符一个字符地改变字符串数组的内容，但不能像strarray="new string"这样直接初始化其他字符串，这是无效的

指针

我们都知道指针指向内存中的内存位置， 未初始化的指针指向随机内存位置，初始化后指向特定内存位置

char *ptr = "hello";

这里的指针ptr被初始化为字符串“hello”，这是一个存储在只读存储器(ROM)中的常量字符串，所以“hello”不能被更改，因为它存储在ROM中

PTR存储在堆栈部分并指向常量字符串"hello"

所以ptr[0]='m'是无效的，因为你不能访问只读内存

但是ptr可以直接初始化为其他字符串值，因为它只是一个指针，所以它可以指向其数据类型变量的任何内存地址

ptr="new string"; is valid

5.5节K&R的字符指针和功能也讨论了这个主题:

There is an important difference between these definitions: char amessage[] = "now is the time"; /* an array */ char *pmessage = "now is the time"; /* a pointer */ amessage is an array, just big enough to hold the sequence of characters and '\0' that initializes it. Individual characters within the array may be changed but amessage will always refer to the same storage. On the other hand, pmessage is a pointer, initialized to point to a string constant; the pointer may subsequently be modified to point elsewhere, but the result is undefined if you try to modify the string contents.

为什么我得到一个分割错误时写入字符串?

c99n1256草案

字符串字面量有两种不同的用法:

Initialize char[]: char c[] = "abc"; This is "more magic", and described at 6.7.8/14 "Initialization": An array of character type may be initialized by a character string literal, optionally enclosed in braces. Successive characters of the character string literal (including the terminating null character if there is room or if the array is of unknown size) initialize the elements of the array. So this is just a shortcut for: char c[] = {'a', 'b', 'c', '\0'}; Like any other regular array, c can be modified. Everywhere else: it generates an: unnamed array of char What is the type of string literals in C and C++? with static storage that gives UB if modified So when you write: char *c = "abc"; This is similar to: /* __unnamed is magic because modifying it gives UB. */ static char __unnamed[] = "abc"; char *c = __unnamed; Note the implicit cast from char[] to char *, which is always legal. Then if you modify c[0], you also modify __unnamed, which is UB. This is documented at 6.4.5 "String literals": 5 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. For character string literals, the array elements have type char, and are initialized with the individual bytes of the multibyte character sequence [...] 6 It is unspecified whether these arrays are distinct provided their elements have the appropriate values. If the program attempts to modify such an array, the behavior is undefined.

6.7.8/32“初始化”给出了一个直接的例子:

EXAMPLE 8: The declaration char s[] = "abc", t[3] = "abc"; defines "plain" char array objects s and t whose elements are initialized with character string literals. This declaration is identical to char s[] = { 'a', 'b', 'c', '\0' }, t[] = { 'a', 'b', 'c' }; The contents of the arrays are modifiable. On the other hand, the declaration char *p = "abc"; defines p with type "pointer to char" and initializes it to point to an object with type "array of char" with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to modify the contents of the array, the behavior is undefined.

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* it存储在.rodata部分，而不是在.text中。

如果我们对char[]做同样的操作:

 char s[] = "abc";

我们获得:

17:   c7 45 f0 61 62 63 00    movl   $0x636261,-0x10(%rbp)

因此它被存储在堆栈中(相对于%rbp)。

但是请注意，默认的链接器脚本将.rodata和.text放在同一个段中，该段有执行权限，但没有写权限。这可以观察到:

readelf -l a.out

它包含:

 Section to Segment mapping:
  Segment Sections...
   02     .text .rodata

假设字符串是，

char a[] = "string literal copied to stack";
char *p  = "string literal referenced by p";

在第一种情况下，当'a'进入作用域时，文字将被复制。这里'a'是定义在stack上的数组。这意味着字符串将在堆栈上创建，其数据从代码(文本)内存中复制，通常是只读的(这是特定于实现的，编译器也可以将这种只读的程序数据放在可读写内存中)。

在第二种情况下，p是定义在堆栈(本地作用域)上的指针，并引用存储在其他位置的字符串字面量(程序数据或文本)。通常，修改这样的内存不是好的实践，也不鼓励。