¿Por qué utilizar nuevas líneas finales en lugar de liderar con printf?

Escuché que debes evitar las nuevas líneas al usar printf. Entonces, en lugar de printf("\nHello World!")usarprintf("Hello World!\n")

En este ejemplo particular anterior no tiene sentido, ya que la salida sería diferente, pero considere esto:

printf("Initializing");
init();
printf("\nProcessing");
process_data();
printf("\nExiting");

comparado con:

printf("Initializing\n");
init();
printf("Processing\n");
process_data();
printf("Exiting");

No puedo ver ningún beneficio con las nuevas líneas finales, excepto que se ve mejor. ¿Hay alguna otra razon?

EDITAR:

Me referiré a los votos cerrados aquí y ahora. No creo que esto pertenezca al desbordamiento de la pila, porque esta pregunta es principalmente sobre diseño. También me gustaría decir que aunque puede ser opiniones a este asunto, la respuesta de Kilian Foth y la respuesta de cmaster demuestra que efectivamente existen beneficios muy objetivo con un enfoque.

Una buena cantidad de E / S de terminal está almacenada en línea , por lo que al finalizar un mensaje con \ n puede estar seguro de que se mostrará de manera oportuna. Con un \ n inicial, el mensaje puede mostrarse o no a la vez. A menudo, esto significaría que cada paso muestra el mensaje de progreso del paso anterior , lo que causa un sinfín de confusión y pérdida de tiempo cuando intenta comprender el comportamiento de un programa.

En los sistemas POSIX (básicamente cualquier Linux, BSD, cualquier sistema basado en código abierto que pueda encontrar), una línea se define como una cadena de caracteres que termina en una nueva línea \n. Esta es la premisa básica de todas las herramientas de línea de comandos estándar se basan en, incluyendo (pero no limitado a) wc, grep, sed, awk, y vim. Esta es también la razón por la cual algunos editores (como vim) siempre agregan un \nal final de un archivo, y por qué los estándares anteriores de C requerían que los encabezados terminaran con un \ncarácter.

Por cierto: tener \nlíneas terminadas hace que el procesamiento de texto sea mucho más fácil: sabes con certeza que tienes una línea completa cuando tienes ese terminador. Y sabes con certeza que necesitas mirar más personajes si aún no has encontrado ese terminador.

Por supuesto, esto está en el lado de entrada de los programas, pero la salida del programa se usa muy a menudo como entrada de programa nuevamente. Por lo tanto, su salida debe cumplir con la convención en aras de permitir la entrada sin problemas en otros programas.

Además de lo que otros han mencionado, siento que hay una razón mucho más simple: es el estándar. Cada vez que algo se imprime en STDOUT, casi siempre supone que ya está en una nueva línea y, por lo tanto, no necesita comenzar una nueva. También supone que la siguiente línea que se escribirá actuará de la misma manera, por lo que termina útilmente al comenzar una nueva línea.

Si imprime líneas de línea nueva y entrelazadas con líneas estándar de línea nueva, "terminará así:

Trailing-newline-line
Trailing-newline-line

Leading-newline-line
Leading-newline-line
Leading-newline-lineTrailing-newline-line
Trailing-newline-line

Leading-newline-lineTrailing-newline-line
Trailing-newline-line
Trailing-newline-line

... que presumiblemente no es lo que quieres.

Si usa solo nuevas líneas iniciales en su código y solo lo ejecuta en un IDE, puede resultar correcto. Tan pronto como lo ejecute en una terminal o introduzca el código de otras personas que escribirá en STDOUT junto con su código, verá una salida no deseada como la anterior.

Dado que las respuestas altamente votadas ya han dado excelentes razones técnicas por las cuales debería preferirse seguir las nuevas líneas, lo abordaré desde otro ángulo.

En mi opinión, lo siguiente hace que un programa sea más legible:

1. Una alta relación señal / ruido (también conocida como simple pero no más simple)
2. las ideas importantes son lo primero

De los puntos anteriores, podemos argumentar que las nuevas líneas finales son mejores. Las nuevas líneas están formateando "ruido" en comparación con el mensaje, el mensaje debe sobresalir y, por lo tanto, debe ser lo primero (el resaltado de sintaxis también puede ayudar).

El uso de líneas nuevas al final simplifica las modificaciones posteriores.

Como un ejemplo (muy trivial) basado en el código del OP, suponga que necesita producir alguna salida antes del mensaje "Inicializando", y esa salida proviene de una parte lógica diferente del código, en un archivo fuente diferente.

Cuando ejecuta la primera prueba y encuentra que "Inicializar" ahora se agrega al final de una línea de alguna otra salida, debe buscar a través del código para encontrar dónde se imprimió, y luego esperar cambiar "Inicializando" a "\ nInicialización "no arruina el formato de otra cosa, en diferentes circunstancias.

Ahora considere cómo manejar el hecho de que su nueva salida es realmente opcional, por lo que su cambio a "\ nInicialización" a veces produce una línea en blanco no deseada al comienzo de la salida ...

¿Establece un indicador global ( shock horror ?? !!! ) que indica si hubo algún resultado anterior y lo prueba para imprimir "Inicializando" con un "\ n" inicial opcional, o genera el "\ n" junto con su salida anterior y deje futuros lectores de códigos preguntándose por qué esta "Inicialización" no tiene un "\ n" inicial como todos los demás mensajes de salida.

Si constantemente genera nuevas líneas finales, en el punto en el que sabe que ha llegado al final de la línea que necesita ser terminada, evita todos esos problemas. Tenga en cuenta que eso puede requerir una declaración de put ("\ n") al final de alguna lógica que genera una línea pieza por pieza, pero el punto es que usted genera la nueva línea en el primer lugar del código donde sabe que necesita hazlo, no en otro lugar.

¿Por qué utilizar nuevas líneas finales en lugar de liderar con printf?

Coincidir estrechamente con la especificación C.

La biblioteca C define una línea como que termina con un carácter de nueva línea '\n' .

Una secuencia de texto es una secuencia ordenada de caracteres compuestos en líneas , cada línea que consta de cero o más caracteres más un carácter de nueva línea que termina. Si la última línea requiere un carácter de nueva línea de terminación está definida por la implementación. C11 §7.21.2 2

El código que escribe datos como líneas coincidirá con el concepto de la biblioteca.

printf("Initializing"); // Write part of a line
printf("\nProcessing"); // Finish prior line & write part of a line
printf("\nExiting");    // Finish prior line & write an implementation-defined last line

printf("Initializing\n");//Write a line 
printf("Processing\n");  //Write a line
printf("Exiting");       //Write an implementation-defined last line

Re: la última línea requiere un carácter de nueva línea de terminación . Recomiendo siempre escribir un final '\n'en la salida y tolerar su ausencia en la entrada.

Corrección ortográfica

Mi corrector ortográfico se queja. Quizás tu también lo haga.

  v---------v Not a valid word
"\nProcessing"

 v--------v OK
"Processing\n");

Las nuevas líneas principales a menudo pueden facilitar la escritura del código cuando hay condicionales, por ejemplo,

printf("Initializing");
if (jobName != null)
    printf(": %s", jobName);
init();
printf("\nProcessing");

(Pero como se ha señalado en otra parte, es posible que deba vaciar el búfer de salida antes de realizar cualquier paso que requiera mucho tiempo de CPU).

Por lo tanto, se puede hacer un buen caso para ambas formas de hacerlo, sin embargo, personalmente no me gusta printf () y usaría una clase personalizada para construir la salida.

Las nuevas líneas líderes no funcionan bien con otras funciones de la biblioteca, en particular puts()y perroren la Biblioteca estándar, sino también con cualquier otra biblioteca que pueda usar.

Si desea imprimir una línea preescrita (ya sea una constante o una ya formateada, por ejemplo, con sprintf()), entonces puts()es la opción natural (y eficiente). Sin embargo, no hay forma de puts()terminar la línea anterior y escribir una línea sin terminar; siempre escribe el terminador de línea.