В каком сегменте данных хранится строка C?

Ответ 1

Вы правы, что "привет" для первого случая является изменяемым, а для второго - неизменяемой строкой. И до инициализации они хранятся в памяти только для чтения.

В первом случае измененная память инициализируется/копируется из неизменяемой строки. Во втором случае указатель ссылается на неизменяемую строку.

В первом случае википедия говорит,

Значения для этих переменных изначально хранятся в пределах постоянное запоминающее устройство (обычно внутри .text) и копируется в .data во время запуска программы.

Рассмотрим файл segment.c.

char*s = "hello"; // string
char sar[] = "hello"; // string array
char content[32];

int main(int argc, char*argv[]) {
        char psar[] = "parhello"; // local/private string array
        char*ps = "phello"; // private string
        content[0] = 1;
        sar[3] = 1; // OK
        // sar++; // not allowed
        // s[2] = 1; // segmentation fault
        s = sar;
        s[2] = 1; // OK
        psar[3] = 1; // OK
        // ps[2] = 1; // segmentation fault
        ps = psar;
        ps[2] = 1; // OK
        return 0;
}

Вот сборка, сгенерированная для файла segment.c. Обратите внимание, что как s, так и sar находится в сегменте global aka .data. Кажется, что sar есть const pointer к изменяемой инициализированной памяти или вообще не указателю (практически это массив). И в конечном итоге это подразумевает, что sizeof(sar) = 6 отличается от sizeof(s) = 8. Есть "hello" и "phello" в разделе readonly (.rodata) и эффективно неизменяемы.

    .file   "segment.c"
    .globl  s
    .section    .rodata
.LC0:
    .string "hello"
    .data
    .align 8
    .type   s, @object
    .size   s, 8
s:
    .quad   .LC0
    .globl  sar
    .type   sar, @object
    .size   sar, 6
sar:
    .string "hello"
    .comm   content,32,32
    .section    .rodata
.LC1:
    .string "phello"
    .text
    .globl  main
    .type   main, @function
main:
.LFB0:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    subq    $64, %rsp
    movl    %edi, -52(%rbp)
    movq    %rsi, -64(%rbp)
    movq    %fs:40, %rax
    movq    %rax, -8(%rbp)
    xorl    %eax, %eax
    movl    $1752326512, -32(%rbp)
    movl    $1869376613, -28(%rbp)
    movb    $0, -24(%rbp)
    movq    $.LC1, -40(%rbp)
    movb    $1, content(%rip)
    movb    $1, sar+3(%rip)
    movq    $sar, s(%rip)
    movq    s(%rip), %rax
    addq    $2, %rax
    movb    $1, (%rax)
    movb    $1, -29(%rbp)
    leaq    -32(%rbp), %rax
    movq    %rax, -40(%rbp)
    movq    -40(%rbp), %rax
    addq    $2, %rax
    movb    $1, (%rax)
    movl    $0, %eax
    movq    -8(%rbp), %rdx
    xorq    %fs:40, %rdx
    je  .L2
    call    __stack_chk_fail
.L2:
    leave
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE0:
    .size   main, .-main
    .ident  "GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3"
    .section    .note.GNU-stack,"",@progbits

Опять для локальной переменной main, компилятор не пытается создать имя. И он может хранить его в регистре или в памяти стека.

Обратите внимание, что значение локальной переменной parhello оптимизировано на номера 1752326512 и 1869376613. Я обнаружил это, изменив значение "parhello" на "parhellp". Разность выходного сигнала сборки следующая:

39c39
<   movl    $1886153829, -28(%rbp)
---
>   movl    $1869376613, -28(%rbp)

Таким образом, для psar нет отдельного неизменяемого хранилища. Он превращается в целые числа в сегменте кода.

Ответ 2

ответьте на свой первый вопрос:

char s[] = "hello";

s - это массив типа char. Массив - это указатель const, означающий, что вы не можете изменить s с помощью арифметики указателя (т.е. s++). Однако данные не const, поэтому вы можете изменить его.
См. Пример кода C:

#include <stdio.h>

void reverse(char *p){
    char c;
    char* q = p;
    while (*q) q++; 
    q--; // point to the end
    while (p < q) {
        c = *p;
        *p++ = *q;
        *q-- = c;
    }
}

int main(){
    char s[]  = "DCBA";
    reverse( s);
    printf("%s\n", s); // ABCD
}

который меняет текст "DCBA" и производит "ABCD".

char *p = "hello"

p является указателем на char. Вы можете выполнить арифметику указателя - p++ скомпилировать - и помещает данные в части памяти только для чтения (данные const).
и использование p[0]='a'; приведет к ошибке времени выполнения:

#include <stdio.h>
int main(){
    char* s  = "DCBA";  
    s[0]='D'; // compile ok but runtime error
    printf("%s\n", s); // ABCD
}  

это компиляция, но не выполняется.

const char* const s = "DCBA";

С помощью const char* const вы не можете изменить ни s, ни содержимое данных, которое указывает на (т.е. "DCBE"). поэтому данные и указатель являются константами:

#include <stdio.h>
int main(){
    const char* const s  = "DCBA";  
    s[0]='D'; // compile error
    printf("%s\n", s); // ABCD
}

Сегмент текста обычно является сегментом, где хранится ваш код, и const; т.е. неизменяемым. Во встроенных системах это ROM, PROM или флэш-память; на настольном компьютере он может находиться в ОЗУ.

Стек - это оперативная память, используемая для локальных переменных в функциях.

"Куча" - это оперативная память, используемая для глобальных переменных и данных, инициализированных кучей.

BSS содержит все глобальные переменные и статические переменные, которые инициализируются нулевыми или не инициализированными vars.

Для получения дополнительной информации см. соответствующая Википедия и этот важный вопрос о переполнении стека

Что касается самого s: компилятор решает, куда его поместить (в стеке или регистры процессора).

Для получения дополнительной информации о защите памяти и нарушениях доступа или ошибках сегментации см. соответствующую страницу Википедии

Это очень широкая тема, и в конечном итоге точные ответы зависят от вашего оборудования и компилятора.