En C, ¿se puede dividir una instrucción printf larga en varias líneas?

4 minutos de lectura

En C ¿se puede dividir una instruccion printf larga en
neuromante

Tengo la siguiente declaración:

printf("name: %s\targs: %s\tvalue %d\tarraysize %d\n", sp->name, sp->args, sp->value, sp->arraysize);

Quiero romperlo. Intenté lo siguiente pero no funciona.

printf("name: %s\t
args: %s\t
value %d\t
arraysize %d\n", 
sp->name, 
sp->args, 
sp->value, 
sp->arraysize);

¿Cómo puedo romperlo?

  • Algunas buenas sugerencias dadas, pero ninguna de ellas puede ser tan clara o mantenible como solo cuatro llamadas printf() separadas.

    – Clifford

    17 de noviembre de 2009 a las 23:45

  • @Clifford: entonces podría escribir C ++ para que cout se vea mejor para usted.

    – Prueba

    18 de noviembre de 2009 a las 7:17

Si desea dividir un literal de cadena en varias líneas, puede concatenar varias cadenas juntas, una en cada línea, así:

printf("name: %s\t"
"args: %s\t"
"value %d\t"
"arraysize %d\n", 
sp->name, 
sp->args, 
sp->value, 
sp->arraysize);

  • solo comentando para explicar el hecho poco conocido de C de que el espacio en blanco entre dos cadenas es concatenación.

    –Brian Postow

    17 de noviembre de 2009 a las 22:00

  • @Lundin Tener cada variable y su valor claramente representado en su propia línea es mucho más fácil de leer para mí. ¿Te imaginas un depurador en un IDE que ponga todas las variables y valores en una sola línea? No puedo. (Sí, sé que no coloca caracteres de nueva línea entre cada cadena, pero estoy comparando la legibilidad del código fuente con la legibilidad de las variables en un depurador)

    – byxor

    11 de julio de 2017 a las 16:33


  • ¿Esta concatenación la hace el preprocesador?

    – debuti

    5 de diciembre de 2017 a las 15:07

En C ¿se puede dividir una instruccion printf larga en
qrdl

El compilador de C puede unir literales de cadena adyacentes en uno, como

printf("foo: %s "
       "bar: %d", foo, bar);

El preprocesador puede usar una barra invertida como último carácter de la línea, sin contar CR (o CR/LF, si es de Windowsland):

printf("foo %s \
bar: %d", foo, bar);

  • El primero ya ha sido sugerido, el segundo adolece del hecho de que se rompe si hay algún espacio en blanco. después los ‘\’; un error que puede ser desconcertante cuando ocurre.

    – Clifford

    17 de noviembre de 2009 a las 23:43

  • Ninguno de esos dos ejemplos tiene nada que ver con el preprocesador C.

    – Moldeado Dan

    18 de noviembre de 2009 a las 5:15

  • @Dan mi cpp parece entender / (ver mi edición anterior). No estoy seguro de si este es un comportamiento estándar.

    – jugo de sig

    18 de noviembre de 2009 a las 7:12

  • @Dan Si bien la unión de literales adyacentes se puede realizar con el preprocesador o el compilador (en la última etapa antes de la compilación real), el preprocesador realiza el manejo de la continuación de la línea, porque de lo contrario no se pueden implementar macros de varias líneas. También vea aquí – gcc.gnu.org/onlinedocs/cpp/Initial-processing.html

    – qrdl

    18 de noviembre de 2009 a las 8:23

  • @qrdl: Mi error, tienes razón sobre el segundo. La continuación de la línea siempre la realiza el preprocesador. A veces necesito que me recuerden que soy no un sabelotodo;) Sin embargo, sigo pensando que, en el caso normal, el compilador une literales de cadena.

    – Moldeado Dan

    18 de noviembre de 2009 a las 18:40

Solo algunas otras opciones de formato:

printf("name: %s\targs: %s\tvalue %d\tarraysize %d\n", 
        a,        b,        c,        d);

printf("name: %s\targs: %s\tvalue %d\tarraysize %d\n", 
              a,        b,        c,            d);

printf("name: %s\t"      "args: %s\t"      "value %d\t"      "arraysize %d\n", 
        very_long_name_a, very_long_name_b, very_long_name_c, very_long_name_d);

Puede agregar variaciones sobre el tema. La idea es que el printf() Los especificadores de conversión y las respectivas variables están todos alineados “muy bien” (para algunos valores de “muy bien”).

  • Nada funcional aquí, pero una idea novedosa que nunca había visto antes. Me gusta, gran comentario @pmg!

    – rpj

    19 de noviembre de 2009 a las 3:07

La forma estándar de facto de dividir funciones complejas en C es por argumento:

printf("name: %s\targs: %s\tvalue %d\tarraysize %d\n", 
       sp->name, 
       sp->args, 
       sp->value, 
       sp->arraysize);

O si quieres:

const char format_str[] = "name: %s\targs: %s\tvalue %d\tarraysize %d\n";
...
printf(format_str, 
       sp->name, 
       sp->args, 
       sp->value, 
       sp->arraysize);

No debe dividir la cadena, ni debe usar \ para romper una línea C. Tal código rápidamente se vuelve completamente ilegible/inmantenible.

En C ¿se puede dividir una instruccion printf larga en
antoine maboula

no pienso usar uno printf La declaración para imprimir literales de cadena como se ve arriba es una buena práctica de programación; más bien, uno puede usar el código a continuación:

printf("name: %s\t",sp->name);
printf("args: %s\t",sp->args);
printf("value: %s\t",sp->value);
printf("arraysize: %s\t",sp->name); 

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad