montón vs segmento de datos vs asignación de pila

Question

Am mirar el siguiente programa y no está seguro de cómo se asigna la memoria y por qué:

void function() { 
    char text1[] = "SomeText"; 
    char* text2 = "Some Text"; 
    char *text = (char*) malloc(strlen("Some Text") + 1); 
} 

En el código anterior, el último es, obviamente, en el montón. Sin embargo, como entiendo, text2 está en el segmento de datos del programa y text1 puede estar en la pila. ¿O es errónea mi suposición? ¿Cuál es la suposición correcta aquí? ¿Es este compilador dependiente?

Gracias

Answer 1

// Array allocated on the stack and initialized with "SomeText" string. 
// It has automatic storage duration. You shouldn't care about freeing memory. 
char text1[] = "SomeText"; 

// Pointer to the constant string "Some Text". 
// It has static storage duration. You shouldn't care about freeing memory. 
// Note that it should be "a pointer to const". 
// In this case you'll be protected from accidential changing of 
// the constant data (changing constant object leads to UB). 
const char* text2 = "Some Text"; 

// malloc will allocate memory on the heap. 
// It has dynamic storage duration. 
// You should call "free" in the end to avoid memory leak. 
char *text = (char*) malloc(strlen("Some Text") + 1); 

Answer 2

Sí tienes razón, en la mayoría de los sistemas:

text1 será una matriz de variables se puede escribir en la pila (se requiere para ser una matriz grabable)

text2 ha ser const char* en realidad, y sí, apuntará a un segmento de texto del ejecutable (pero eso podría cambiar en los formatos ejecutables)

text habrá en el montón