¿Cuál es la diferencia entre char s [] y char * s?

En C, se puede usar un literal de cadena en una declaración como esta:

char s[] = "hello";

o así:

char *s = "hello";

Entonces cuál es la diferencia? Quiero saber qué sucede realmente en términos de duración de almacenamiento, tanto en tiempo de compilación como de ejecución.

La diferencia aquí es que

char *s = "Hello world";

colocará "Hello world"en las partes de solo lectura de la memoria , y haciendos un puntero a eso, cualquier operación de escritura en esta memoria es ilegal.

Mientras se hace:

char s[] = "Hello world";

coloca la cadena literal en la memoria de solo lectura y copia la cadena en la memoria recién asignada en la pila. Haciendo así

s[0] = 'J';

legal.

En primer lugar, en argumentos de función, son exactamente equivalentes:

void foo(char *x);
void foo(char x[]); // exactly the same in all respects

En otros contextos, char *asigna un puntero, mientras que char []asigna una matriz. ¿Dónde va la cuerda en el primer caso, preguntas? El compilador asigna secretamente una matriz anónima estática para contener el literal de cadena. Entonces:

char *x = "Foo";
// is approximately equivalent to:
static const char __secret_anonymous_array[] = "Foo";
char *x = (char *) __secret_anonymous_array;

Tenga en cuenta que nunca debe intentar modificar el contenido de esta matriz anónima a través de este puntero; los efectos son indefinidos (a menudo significan un bloqueo):

x[1] = 'O'; // BAD. DON'T DO THIS.

El uso de la sintaxis de la matriz lo asigna directamente a la nueva memoria. Por lo tanto, la modificación es segura:

char x[] = "Foo";
x[1] = 'O'; // No problem.

Sin embargo, la matriz solo vive mientras su alcance de contagio, por lo que si hace esto en una función, no devuelva ni pierda un puntero a esta matriz; haga una copia en su lugar con strdup()o similar. Si la matriz se asigna en alcance global, por supuesto, no hay problema.

Esta declaración:

char s[] = "hello";

Crea un objeto: una charmatriz de tamaño 6, llamada s, inicializada con los valores 'h', 'e', 'l', 'l', 'o', '\0'. La ubicación de esta matriz en la memoria y el tiempo de vida depende de dónde aparezca la declaración. Si la declaración está dentro de una función, vivirá hasta el final del bloque en el que se declara, y casi con certeza se asignará en la pila; si está fuera de una función, probablemente se almacenará dentro de un "segmento de datos inicializado" que se carga desde el archivo ejecutable en la memoria grabable cuando se ejecuta el programa.

Por otro lado, esta declaración:

char *s ="hello";

Crea dos objetos:

• una matriz de solo lectura de 6 chars que contiene los valores 'h', 'e', 'l', 'l', 'o', '\0', que no tiene nombre y tiene una duración de almacenamiento estático (lo que significa que dura toda la vida del programa); y
• una variable de tipo puntero a char, llamada s, que se inicializa con la ubicación del primer carácter en esa matriz de solo lectura sin nombre.

La matriz de solo lectura sin nombre generalmente se encuentra en el segmento de "texto" del programa, lo que significa que se carga desde el disco en la memoria de solo lectura, junto con el código mismo. La ubicación de la svariable del puntero en la memoria depende de dónde aparece la declaración (como en el primer ejemplo).

Dadas las declaraciones

char *s0 = "hello world";
char s1[] = "hello world";

suponga el siguiente mapa de memoria hipotético:

                    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

El literal de cadena "hello world"es una matriz de 12 elementos char( const charen C ++) con una duración de almacenamiento estático, lo que significa que la memoria para él se asigna cuando se inicia el programa y permanece asignada hasta que finaliza el programa. Intentar modificar el contenido de un literal de cadena invoca un comportamiento indefinido.

La línea

char *s0 = "hello world";

se define s0como un puntero charcon una duración de almacenamiento automático (lo que significa que la variable s0solo existe para el alcance en el que se declara) y le copia la dirección del literal de cadena ( 0x00008000en este ejemplo). Tenga en cuenta que ya s0apunta a un literal de cadena, no debe ser utilizado como un argumento a cualquier función que se trate de modificarlo (por ejemplo, strtok(), strcat(), strcpy(), etc.).

La línea

char s1[] = "hello world";

se define s1como una matriz de 12 elementos de char(la longitud se toma del literal de cadena) con duración de almacenamiento automático y copia el contenido del literal a la matriz. Como puede ver en el mapa de memoria, tenemos dos copias de la cadena "hello world"; la diferencia es que puedes modificar la cadena contenida en s1.

s0y s1son intercambiables en la mayoría de los contextos; Aquí están las excepciones:

sizeof s0 == sizeof (char*)
sizeof s1 == 12

type of &s0 == char **
type of &s1 == char (*)[12] // pointer to a 12-element array of char

Puede reasignar la variable s0para que apunte a un literal de cadena diferente u otra variable. No puede reasignar la variable s1para que apunte a una matriz diferente.

C99 N1256 draft

Hay dos usos diferentes de los literales de cadena de caracteres:

1. Inicializar char[]:

   char c[] = "abc";      

   Esto es "más mágico", y se describe en 6.7.8 / 14 "Inicialización":

   Una matriz de tipo de caracteres puede ser inicializada por una cadena de caracteres literal, opcionalmente encerrada entre llaves. Los caracteres sucesivos del literal de cadena de caracteres (incluido el carácter nulo de terminación si hay espacio o si la matriz es de tamaño desconocido) inicializan los elementos de la matriz.

   Entonces esto es solo un atajo para:

   char c[] = {'a', 'b', 'c', '\0'};

   Al igual que cualquier otra matriz regular, cse puede modificar.

2. En todas partes: genera un:

   • sin nombre
   • array of char ¿Cuál es el tipo de literales de cadena en C y C ++?
   • con almacenamiento estático
   • que da UB si se modifica

   Entonces cuando escribes:

   char *c = "abc";

   Esto es similar a:

   /* __unnamed is magic because modifying it gives UB. */
   static char __unnamed[] = "abc";
   char *c = __unnamed;

   Tenga en cuenta la conversión implícita de char[]a char *, que siempre es legal.

   Luego, si modifica c[0], también modifica __unnamed, que es UB.

   Esto se documenta en 6.4.5 "Literales de cadena":

   5 En la fase de traducción 7, se agrega un byte o código de valor cero a cada secuencia de caracteres multibyte que resulta de una cadena literal o literales. La secuencia de caracteres multibyte se usa para inicializar una matriz de duración y longitud de almacenamiento estático, lo suficiente como para contener la secuencia. Para los literales de cadena de caracteres, los elementos de la matriz tienen el tipo char y se inicializan con los bytes individuales de la secuencia de caracteres multibyte [...]

   6 No se especifica si estas matrices son distintas siempre que sus elementos tengan los valores apropiados. Si el programa intenta modificar dicha matriz, el comportamiento es indefinido.

6.7.8 / 32 "Inicialización" da un ejemplo directo:

EJEMPLO 8: La declaración

char s[] = "abc", t[3] = "abc";

define objetos de matriz de caracteres "simples" sy tcuyos elementos se inicializan con literales de cadena de caracteres.

Esta declaración es idéntica a

char s[] = { 'a', 'b', 'c', '\0' },
t[] = { 'a', 'b', 'c' };

Los contenidos de las matrices son modificables. Por otro lado, la declaración

char *p = "abc";

define pcon el tipo "puntero a char" y lo inicializa para apuntar a un objeto con el tipo "matriz de char" con longitud 4 cuyos elementos se inicializan con una cadena de caracteres literal. Si se intenta utilizar ppara modificar el contenido de la matriz, el comportamiento no está definido.

Implementación de GCC 4.8 x86-64 ELF

Programa:

#include <stdio.h>

int main(void) {
    char *s = "abc";
    printf("%s\n", s);
    return 0;
}

Compilar y descompilar:

gcc -ggdb -std=c99 -c main.c
objdump -Sr main.o

La salida contiene:

 char *s = "abc";
8:  48 c7 45 f8 00 00 00    movq   $0x0,-0x8(%rbp)
f:  00 
        c: R_X86_64_32S .rodata

Conclusión: GCC lo almacena char*en .rodatasección, no en .text.

Sin embargo , tenga en cuenta que la secuencia de comandos del vinculador predeterminado coloca .rodatay .texten el mismo segmento , que tiene permiso de ejecución pero no escritura. Esto se puede observar con:

readelf -l a.out

que contiene:

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

Si hacemos lo mismo para char[]:

 char s[] = "abc";

obtenemos:

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

por lo que se almacena en la pila (en relación con %rbp).

char s[] = "hello";

declara sser una matriz charcuyo tiempo es suficiente para contener el inicializador (5 + 1 chars) e inicializa la matriz copiando los miembros de la cadena literal literal en la matriz.

char *s = "hello";

declara sser un puntero a uno o más (en este caso más) charsy lo apunta directamente a una ubicación fija (solo lectura) que contiene el literal "hello".

char s[] = "Hello world";

Aquí shay una serie de caracteres que se pueden sobrescribir si lo deseamos.

char *s = "hello";

Se utiliza un literal de cadena para crear estos bloques de caracteres en algún lugar de la memoria al que sapunta este puntero . Aquí podemos reasignar el objeto al que apunta cambiando eso, pero siempre que apunte a una cadena literal, el bloque de caracteres al que apunta no se puede cambiar.

Además, considere que, para fines de solo lectura, el uso de ambos es idéntico, puede acceder a un carácter indexando con []o con *(<var> + <index>) formato:

printf("%c", x[1]);     //Prints r

Y:

printf("%c", *(x + 1)); //Prints r

Obviamente, si intentas hacer

*(x + 1) = 'a';

Probablemente obtendrá un error de segmentación, ya que está intentando acceder a la memoria de solo lectura.

Solo para agregar: también obtienes diferentes valores para sus tamaños.

printf("sizeof s[] = %zu\n", sizeof(s));  //6
printf("sizeof *s  = %zu\n", sizeof(s));  //4 or 8

Como se mencionó anteriormente, para una matriz '\0'se asignará como el elemento final.

char *str = "Hello";

Lo anterior establece que str apunte al valor literal "Hola", que está codificado en la imagen binaria del programa, que está marcado como de solo lectura en la memoria, significa que cualquier cambio en este literal de cadena es ilegal y arrojaría fallas de segmentación.

char str[] = "Hello";

copia la cadena a la memoria recién asignada en la pila. Por lo tanto, cualquier cambio en él está permitido y es legal.

means str[0] = 'M';

cambiará el str a "Mello".

Para obtener más detalles, consulte la pregunta similar:

¿Por qué aparece un error de segmentación al escribir en una cadena inicializada con "char * s" pero no "char s []"?

En el caso de:

char *x = "fred";

x es un valor l , se le puede asignar. Pero en el caso de:

char x[] = "fred";

x no es un valor l, es un valor r, no se le puede asignar.

char *s1 = "Hello world"; // Points to fixed character string which is not allowed to modify
char s2[] = "Hello world"; // As good as fixed array of characters in string so allowed to modify

// s1[0] = 'J'; // Illegal
s2[0] = 'J'; // Legal

A la luz de los comentarios aquí, debería ser obvio que: char * s = "hola"; Es una mala idea, y debe usarse en un ámbito muy limitado.

Esta podría ser una buena oportunidad para señalar que la "corrección constante" es una "cosa buena". Siempre que pueda, use la palabra clave "const" para proteger su código, de las personas que llaman o los programadores "relajados", que generalmente son más "relajados" cuando entran en juego los punteros.

Suficiente melodrama, esto es lo que uno puede lograr al adornar punteros con "const". (Nota: hay que leer las declaraciones de puntero de derecha a izquierda). Estas son las 3 formas diferentes de protegerse cuando se juega con punteros:

const DBJ* p means "p points to a DBJ that is const" 

- es decir, el objeto DBJ no se puede cambiar a través de p.

DBJ* const p means "p is a const pointer to a DBJ" 

- es decir, puede cambiar el objeto DBJ a través de p, pero no puede cambiar el puntero p mismo.

const DBJ* const p means "p is a const pointer to a const DBJ" 

- es decir, no puede cambiar el puntero p, ni puede cambiar el objeto DBJ a través de p.

Los errores relacionados con los intentos de mutaciones const-ant se detectan en tiempo de compilación. No hay tiempo de ejecución ni penalización de velocidad para const.

(Por supuesto, ¿está utilizando el compilador de C ++?)

--DBJ