String literals

Construye un objeto sin nombre de tipo de arreglo de caracteres especificado en el lugar, utilizado cuando una cadena de caracteres necesita estar incrustada en el código fuente.

Sintaxis

donde

Explicación

Primero, en la fase de traducción 6 (después de la expansión de macros), los literales de cadena adyacentes (es decir, literales de cadena separados únicamente por espacios en blanco) se concatenan.

L"Δx = %" PRId16 // at phase 4, PRId16 expands to "d"
                 // at phase 6, L"Δx = %" and "d" form L"Δx = %d"

En segundo lugar, en la fase de traducción 7 , se añade un carácter nulo de terminación a cada literal de cadena, y luego cada literal inicializa un array sin nombre con duración de almacenamiento estática y longitud justa para contener el contenido del literal de cadena más uno para el terminador nulo.

char* p = "\x12" "3"; // crea un array char[3] estático que contiene {'\x12', '3', '\0'}
                      // establece p para que apunte al primer elemento del array

Los literales de cadena son no modificables (y de hecho pueden ubicarse en memoria de solo lectura como .rodata ). Si un programa intenta modificar el array estático formado por un literal de cadena, el comportamiento es indefinido.

char* p = "Hello";
p[1] = 'M'; // Comportamiento indefinido
char a[] = "Hello";
a[1] = 'M'; // OK: a no es un literal de cadena

No es requerido ni prohibido que los literales de cadena idénticos se refieran a la misma ubicación en memoria. Además, los literales de cadena superpuestos o los literales de cadena que son subcadenas de otros literales de cadena pueden combinarse.

"def" == 3+"abcdef"; // puede ser 1 o 0, definido por la implementación

Notas

Un literal de cadena no es necesariamente una cadena; si un literal de cadena tiene caracteres nulos incrustados, representa un arreglo que contiene más de una cadena:

char* p = "abc\0def"; // strlen(p) == 3, pero el array tiene tamaño 8

Si un dígito hexadecimal válido sigue a un escape hexadecimal en un literal de cadena, fallaría al compilar como una secuencia de escape inválida, pero se puede usar la concatenación de cadenas como solución alternativa:

//char* p = "\xfff"; // error: secuencia de escape hexadecimal fuera de rango
char* p = "\xff""f"; // correcto, el literal es char[3] que contiene {'\xff', 'f', '\0'}

Los literales de cadena pueden utilizarse para inicializar arrays , y si el tamaño del array es uno menos que el tamaño del literal de cadena, se ignora el terminador nulo:

char a1[] = "abc"; // a1 es char[4] que contiene {'a', 'b', 'c', '\0'}
char a2[4] = "abc"; // a2 es char[4] que contiene {'a', 'b', 'c', '\0'}
char a3[3] = "abc"; // a3 es char[3] que contiene {'a', 'b', 'c'}

La codificación de los literales de cadena de caracteres (1) y los literales de cadena anchos (5) está definida por la implementación. Por ejemplo, gcc los selecciona con las opciones de línea de comandos - fexec - charset y - fwide - exec - charset .

Aunque la concatenación de literales de cadena anchas mixtas está permitida en C11, casi todos los compiladores rechazan dicha concatenación (la única excepción conocida es SDCC ), y su experiencia de uso es desconocida. Como resultado, la permisividad de concatenación de literales de cadena anchas mixtas se elimina en C23.

Ejemplo

#include <inttypes.h>
#include <locale.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <uchar.h>
int main(void)
{
    char s1[] = "a猫🍌"; // or "a\u732B\U0001F34C"
#if __STDC_VERSION__ >= 202311L
    char8_t
#else
    char
#endif
    s2[] = u8"a猫🍌";
    char16_t s3[] = u"a猫🍌";
    char32_t s4[] = U"a猫🍌";
    wchar_t s5[] = L"a猫🍌";
    setlocale(LC_ALL, "en_US.utf8");
    printf("  \"%s\" is a char[%zu] holding     { ", s1, sizeof s1 / sizeof *s1);
    for(size_t n = 0; n < sizeof s1 / sizeof *s1; ++n)
        printf("0x%02X ", +(unsigned char)s1[n]);
    puts("}");
    printf(
#if __STDC_VERSION__ >= 202311L
    "u8\"%s\" is a char8_t[%zu] holding  { "
#else
    "u8\"%s\" is a char[%zu] holding     { "
#endif
, s2, sizeof s2 / sizeof *s2);
    for(size_t n = 0; n < sizeof s2 / sizeof *s2; ++n)
#if __STDC_VERSION__ >= 202311L
       printf("0x%02X ", s2[n]);
#else
       printf("0x%02X ", +(unsigned char)s2[n]);
#endif
    puts("}");
    printf(" u\"a猫🍌\" is a char16_t[%zu] holding { ", sizeof s3 / sizeof *s3);
    for(size_t n = 0; n < sizeof s3 / sizeof *s3; ++n)
       printf("0x%04" PRIXLEAST16" ", s3[n]);
    puts("}");
    printf(" U\"a猫🍌\" is a char32_t[%zu] holding { ", sizeof s4 / sizeof *s4);
    for(size_t n = 0; n < sizeof s4 / sizeof *s4; ++n)
       printf("0x%08" PRIXLEAST32" ", s4[n]);
    puts("}");
    printf(" L\"%ls\" is a wchar_t[%zu] holding  { ", s5, sizeof s5 / sizeof *s5);
    for(size_t n = 0; n < sizeof s5 / sizeof *s5; ++n)
       printf("0x%08X ", (unsigned)s5[n]);
    puts("}");
}

  "a猫🍌" is a char[9] holding     { 0x61 0xE7 0x8C 0xAB 0xF0 0x9F 0x8D 0x8C 0x00 }
u8"a猫🍌" is a char[9] holding     { 0x61 0xE7 0x8C 0xAB 0xF0 0x9F 0x8D 0x8C 0x00 }
 u"a猫🍌" is a char16_t[5] holding { 0x0061 0x732B 0xD83C 0xDF4C 0x0000 }
 U"a猫🍌" is a char32_t[4] holding { 0x00000061 0x0000732B 0x0001F34C 0x00000000 }
 L"a猫🍌" is a wchar_t[4] holding  { 0x00000061 0x0000732B 0x0001F34C 0x00000000 }

Referencias

Véase también