HOWTO · C++

Declare la cadena multilínea en C++

Este artículo demuestra cómo declarar una cadena multilínea en C++

En esta página

Las cadenas multilínea son importantes cuando trabajas con texto extenso o quieres conservar el formato en tu código fuente. C++ no tiene un tipo dedicado para cadenas multilínea, pero ofrece varias formas de construir una: literales de cadena adyacentes, literales de cadena en crudo, empalme con barra invertida y salto de línea, y stringificación del preprocesador. Las técnicas difieren sobre todo en si los saltos de línea del código fuente se convierten en saltos de línea del valor.

Esta guía recorre cada enfoque con ejemplos ejecutables y termina con una comparación para que puedas elegir el adecuado para tu código.

Construye una cadena multilínea con literales de cadena adyacentes

Cuando el compilador encuentra dos o más literales de cadena entre comillas dobles colocados uno junto a otro, separados solo por espacios en blanco, los concatena en un único valor en tiempo de compilación. Dividir un literal en varias líneas del código fuente es puramente una decisión de formato: no se añade ningún salto de línea al valor a menos que escribas \n tú mismo, y los espacios deben incluirse explícitamente donde las palabras deban permanecer separadas.

Ejecuta este ejemplo:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

#include <iostream>
#include <string>

int main() {
  std::string message =
      "I love"
      " getting my doubts solved"
      " by the help of Delft Stack Tutorials.";

  std::cout << message << std::endl;
  return 0;
}
I love getting my doubts solved by the help of Delft Stack Tutorials.

La concatenación de literales adyacentes funciona igual cuando el destino es un const char * —un puntero de solo lectura al literal— en lugar de un objeto std::string:

#include <cstdio>

int main() {
  const char *lines =
      "Line 1 "
      "Line 2 "
      "Line 3";

  std::printf("%s\n", lines);
  return 0;
}
Line 1 Line 2 Line 3

Elige std::string cuando el texto vaya a modificarse o a pasarse a APIs que trabajen con cadenas; un const char * es adecuado para texto estático que solo se imprime o se inspecciona.

Conserva los saltos de línea con literales de cadena en crudo

C++11 añadió los literales de cadena en crudo, que permiten que los saltos de línea físicos formen parte del propio literal. Todo lo que se encuentra entre R"( y )" —incluidos los saltos de línea, la sangría, las comillas y las barras invertidas— pasa a formar parte del valor de forma literal, por lo que no se necesitan secuencias de escape:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

#include <iostream>
#include <string>

int main() {
  std::string page = R"(I love
getting my doubts solved
by the help of Delft Stack Tutorials.)";

  std::cout << page << std::endl;
  return 0;
}
I love
getting my doubts solved
by the help of Delft Stack Tutorials.

Como el contenido se copia literalmente, ten en cuenta dos detalles: un salto de línea escrito justo después del R"( inicial se guarda en el valor, y la sangría que precede a las líneas de continuación también se conserva. Si tu texto contiene alguna vez la secuencia )", elige un delimitador personalizado como R"tag(...)tag": el marcador de cierre entonces requiere la etiqueta, de modo que un )" aislado dentro del texto es inofensivo.

Continúa un literal de cadena con el empalme de barra invertida y salto de línea

Una barra invertida como último carácter de una línea del código fuente empalma esa línea con la siguiente antes de la compilación. Dentro de un literal de cadena, esto permite que el literal ocupe varias líneas del código fuente, pero el salto de línea empalmado se elimina: no produce un salto de línea en el valor. Esa es la diferencia clave con la secuencia de escape \n, que sí añade un salto de línea:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

#include <cstdio>

int main() {
  const char *text =
      "First line\n"
      "Second line\n\
      Third line\n";

  std::printf("%s", text);
  return 0;
}
First line
Second line
      Third line

La salida muestra ambos mecanismos en acción: cada \n escribe un salto de línea, mientras que el empalme con barra invertida solo une las líneas del código fuente, y los espacios iniciales de la línea continuada se convierten en caracteres reales del valor. Esa sensibilidad a los espacios en blanco es el principal peligro: la sangría escrita para mejorar la legibilidad acaba dentro de la cadena, y cualquier carácter tras la barra invertida, incluso un espacio, rompe el empalme. Usa el empalme solo donde controles por completo la disposición del código circundante.

Comprende las limitaciones de la stringificación con macros

Una macro variádica puede convertir sus argumentos en un literal de cadena con el operador de stringificación, como en #define MULTILINE_STRING(...) #__VA_ARGS__. Pasar texto repartido en varias líneas produce un único literal entre comillas, pero el preprocesador normaliza cada secuencia de espacios en blanco, incluidos los saltos de línea, reduciéndola a un solo espacio:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

#include <iostream>
#include <string>

#define MULTILINE_STRING(...) #__VA_ARGS__

int main() {
  std::string message = MULTILINE_STRING(
      I love getting my doubts solved by the help of Delft Stack Tutorials.);

  std::cout << message << std::endl;
  return 0;
}
I love getting my doubts solved by the help of Delft Stack Tutorials.

Esto convierte a la stringificación con macros en una opción limitada, no en una herramienta de propósito general para cadenas multilínea. No puede conservar los saltos de línea, el texto del argumento se tokeniza en lugar de tratarse como contenido de cadena (por lo que un signo de puntuación suelto puede producir resultados sorprendentes) y el código basado en macros es más difícil de leer y depurar. Recurre a ella solo cuando el código dirigido por el preprocesador necesite de verdad convertir tokens en texto.

Elige la técnica adecuada para cadenas multilínea

  • Los literales de cadena en crudo son la opción por defecto cuando los saltos de línea, la sangría o caracteres como \ y " deben conservarse literalmente en el valor: ideales para bloques de texto incrustados, JSON, SQL o expresiones regulares.
  • Los literales de cadena adyacentes dan un control preciso sobre el valor manteniendo cortas las líneas del código fuente; cada espacio y cada \n es explícito, así que no se cuela nada no deseado.
  • El empalme con barra invertida y salto de línea es frágil y sensible a la sangría; sobrevive sobre todo en código heredado y en definiciones de macros, donde sigue siendo necesario para continuar una definición en varias líneas.
  • La stringificación con macros solo encaja en código que depende mucho del preprocesador y que realmente necesita convertir tokens en texto.

Para un valor que realmente ocupa varias líneas, usa un literal de cadena en crudo. Para un valor largo de una sola línea distribuido por tu código fuente, los literales adyacentes son lo más claro, y combinan de forma natural tanto con std::string como con un const char *.