Literales de cadena de C++
Un literal de cadena representa una secuencia de caracteres que, en conjunto, forman una cadena terminada en null. Los caracteres deben escribirse entre comillas. Hay los siguientes tipos de literales de cadena:
Literales de cadena estrechos, representados como "xxx".
Literales de cadena anchos, representados como L"xxx".
Literales de cadena sin formato, representados como R"ddd(xxx) ddd", donde ddd es un delimitador. Los literales de cadena sin formato pueden ser estrechos (representados con R) o anchos (representados con LR).
Un literal de cadena estrecho es una matriz terminada en null de valores char constantes que contiene cualquier carácter gráfico excepto las comillas dobles ("), la barra diagonal inversa (\) o el carácter de nueva línea. Un literal de cadena estrecho puede contener las secuencias de escape enumeradas en Literales de caracteres de C++.
const char *narrow = "abcd";
// represents the string: yes\no
const char *escaped = "yes\\no";
Un literal de cadena ancho es una matriz terminada en null de valores wchar_t constantes que contiene cualquier carácter gráfico excepto las comillas dobles ("), la barra diagonal inversa (\) o el carácter de nueva línea. Un literal de cadena ancho puede contener las secuencias de escape enumeradas en Literales de caracteres de C++.
const wchar_t* wide = L"zyxw";
const wchar_t* newline = L"hello\ngoodbye";
Un literal de cadena sin formato es una matriz terminada en null (de valores char constantes o valores wchar_t constantes) que contiene cualquier carácter gráfico, incluidas las comillas dobles ("), la barra diagonal inversa (\) o el carácter de nueva línea. Los literales de cadena sin formato suelen usarse en expresiones regulares que utilizan clases de caracteres, y en las cadenas HTML y XML. Consulte algunos ejemplos en el artículo siguiente: Preguntas más frecuentes sobre C++11 por Bjarne Stroustrup.
// represents the string: An unescaped \ character
const char* raw_narrow = R"(An unescaped \ character)";
// represents the string: An unescaped " character
const wchar_t* raw_wide = LR"(An unescaped " character)";
Un delimitador es una secuencia definida por el usuario de hasta 16 caracteres que precede inmediatamente al paréntesis de apertura de un literal de cadena sin formato, y sigue inmediatamente a su paréntesis de cierre. Puede utilizar un delimitador para eliminar la ambigüedad de las cadenas que contienen dobles comillas y paréntesis. Esta llamada provoca un error del compilador:
// meant to represent the string: )”
const char* bad_parens = R"()")";
Pero un delimitador lo resuelve:
const char* good_parens = R"xyz()")xyz";
Puede construir un literal de cadena sin formato en el que haya una línea nueva (no el carácter de escape) en el código fuente:
// represents the string: hello
//goodbye
const wchar_t* newline = LR"(hello
goodbye)";
Tamaño de literales de cadena
El tamaño (en bytes) de un literal de cadena estrecho es el número de caracteres más 1 (para el carácter nulo final); el tamaño (en bytes) de un literal de cadena ancho es el número de caracteres multiplicado por 2 más 2 (para el carácter nulo final). A continuación se muestra el tamaño de un literal de cadena ancho:
const wchar_t* str = L"Hello!";
const size_t byteSize = (wcslen(str) + 1) * sizeof(wchar_t);
Observe que strlen() y wcslen() no incluyen el tamaño del carácter null de terminación.
La longitud máxima de un literal de cadena es de 65535 bytes. Este límite se aplica a los literales de cadena estrechos y anchos.
Modificación de literales de cadena
Dado que los literales de cadena son constantes, intentar modificarlos (por ejemplo, str[2] = 'A') provoca un error del compilador.
Específicos de Microsoft
En Visual C++, puede utilizar un literal de cadena para inicializar un puntero a char o a wchar_t no constantes. Esto se permite en el código C, pero está desusado en C++98 y se ha eliminado en C++11. Un intento de modificar la cadena produce una infracción de acceso, como en este ejemplo:
wchar_t* str = L"hello";
str[2] = L'a'; // run-time error: access violation
Puede hacer que el compilador emita un error cuando un literal de cadena se convierte en un carácter non_const cuando establece la opción del compilador /Zc:strictStrings (Deshabilitar conversión de tipo de literal de cadena). Es aconsejable declarar punteros que inicialicen literales de cadena utilizando la palabra clave auto, dado que resuelve el tipo (const) correcto. Por ejemplo, este ejemplo detecta un intento de escribir en un literal de cadena en tiempo de compilación:
auto str = L"hello";
str[2] = L'a'; // Compiler error: you cannot assign to a variable that is const
En algunos casos, pueden agruparse literales de cadena idénticos para ahorrar espacio en el archivo ejecutable. En la agrupación de literales de cadena, el compilador hace que todas las referencias a un literal de cadena determinado apunten a la misma ubicación de la memoria, en lugar de apuntar cada una a una instancia distinta del literal de cadena. Para habilitar la agrupación de cadenas, use la opción del compilador /GF.
Fin de Específicos de Microsoft
Concatenación de literales de cadena adyacentes
Los literales de cadena adyacentes se concatenan. Esta declaración:
char str[] = "12" "34";
es idéntica a esta declaración:
char atr[] = "1234";
y a esta declaración:
char atr[] = "12\
34";
El uso de códigos de escape hexadecimales incrustados para especificar constantes de cadena puede producir resultados inesperados. El ejemplo siguiente está pensado para crear un literal de cadena que contiene el carácter ASCII 5, seguido de los caracteres f, i, v y e:
"\x05five"
El resultado real es 5F hexadecimal, que es el código ASCII de un carácter de subrayado, seguido de los caracteres i, v y e. Para obtener el resultado correcto, puede utilizar una de las siguientes declaraciones:
"\005five" // Use octal constant.
"\x05" "five" // Use string splicing.
Literales de cadena con caracteres Unicode
Los pares suplentes y los caracteres adicionales (como en UTF-16) se representan con un prefijo \U. Estas son cadenas anchas en lugar de caracteres individuales, y se representan con comillas dobles en lugar de comillas simples. No se admiten los prefijos U, u y u8.
const wchar_t* str1 = L"\U0002008A";
const wchar_t* str2 = L"\UD869DED6";
const wchar_t* str3 = L"\Udc00c800";
Para obtener más información sobre Unicode, consulte Unicode. Para obtener más información sobre pares suplentes, consulte Pares suplentes y caracteres adicionales.