Perché usare le nuove righe finali anziché le prime con printf?

Ho sentito che dovresti evitare di guidare le nuove linee quando usi printf. In modo che al posto printf("\nHello World!")tuo dovresti usareprintf("Hello World!\n")

In questo esempio particolare sopra non ha senso, poiché l'output sarebbe diverso, ma considera questo:

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

rispetto a:

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

Non riesco a vedere alcun beneficio con le nuove righe finali, tranne per il fatto che sembra migliore. C'è qualche altro motivo?

MODIFICARE:

Mi rivolgerò ai voti stretti qui e ora. Non penso che questo appartenga allo overflow dello Stack, perché questa domanda riguarda principalmente il design. Direi anche che, sebbene possano essere opinioni in merito, la risposta di Kilian Foth e la risposta di cmaster dimostrano che ci sono davvero vantaggi molto oggettivi con un approccio.

Una buona quantità di I / O del terminale è bufferizzata , quindi terminando un messaggio con \ n si può essere certi che verrà visualizzato in modo tempestivo. Con un \ n iniziale, il messaggio può essere visualizzato o meno in una volta. Spesso, ciò significherebbe che ogni passaggio visualizza il messaggio di avanzamento del passaggio precedente , che non provoca confusione e perdite di tempo quando si tenta di comprendere il comportamento di un programma.

Sui sistemi POSIX (praticamente qualsiasi Linux, BSD, qualunque sistema basato su open source che puoi trovare), una linea è definita come una stringa di caratteri che termina con una nuova riga \n. Questo è l'assunto di base di tutti gli strumenti a riga di comando standard di costruire su, tra cui (ma non solo) wc, grep, sed, awk, e vim. Questo è anche il motivo per cui alcuni editor (come vim) aggiungono sempre \na alla fine di un file e perché gli standard precedenti di C richiedevano che le intestazioni terminassero con un \ncarattere.

Btw: Avere \nterminate le righe rende molto più semplice l'elaborazione del testo: sai per certo che hai una riga completa quando hai quel terminatore. E sai per certo che devi guardare più personaggi se non hai ancora incontrato quel terminatore.

Ovviamente, questo è sul lato dell'input dei programmi, ma l'output del programma viene molto spesso usato come input del programma. Pertanto, l'output dovrebbe attenersi alla convenzione per consentire l'input continuo in altri programmi.

Oltre a ciò che altri hanno già detto, penso che ci sia una ragione molto più semplice: è lo standard. Ogni volta che qualcosa viene stampato su STDOUT, si presume quasi sempre che sia già su una nuova linea e quindi non sia necessario avviarne una nuova. Presuppone inoltre che la riga successiva da scrivere agirà allo stesso modo, quindi termina in modo utile avviando una nuova riga.

Se si generano linee di newline in primo piano interlacciate con linee di trailing-newline standard ", finirà per apparire così:

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

... che presumibilmente non è quello che vuoi.

Se usi solo le nuove linee guida nel tuo codice e lo esegui solo in un IDE, potrebbe andare bene. Non appena lo esegui in un terminale o introduci il codice di altre persone che scriverà su STDOUT insieme al tuo codice, vedrai output indesiderabili come sopra.

Dato che le risposte molto votate hanno già fornito eccellenti ragioni tecniche per cui si dovrebbero preferire le nuove linee finali, mi approverò da un'altra prospettiva.

Secondo me, i seguenti rendono un programma più leggibile:

1. un elevato rapporto segnale-rumore (alias semplice ma non più semplice)
2. le idee importanti vengono prima di tutto

Dai punti di cui sopra, possiamo sostenere che le nuove righe finali sono migliori. Le nuove righe stanno formattando il "rumore" rispetto al messaggio, il messaggio dovrebbe risaltare e quindi dovrebbe venire prima (l'evidenziazione della sintassi può aiutare anche).

L'uso di nuove righe finali semplifica le modifiche successive.

Come esempio (molto banale) basato sul codice dell'OP, supponiamo che sia necessario produrre un output prima del messaggio "Inizializzazione" e che l'output provenga da una diversa parte logica del codice, in un diverso file di origine.

Quando esegui il primo test e scopri che "Inizializzazione" è ora aggiunto alla fine di una riga di qualche altro output, devi cercare attraverso il codice per trovare dove è stato stampato, e quindi sperare di cambiare "Inizializzazione" in "\ nInizializzazione "non rovina il formato di qualcos'altro, in circostanze diverse.

Ora considera come gestire il fatto che il tuo nuovo output sia effettivamente facoltativo, quindi la tua modifica a "\ nInizializzazione" a volte produce una riga vuota indesiderata all'inizio dell'output ...

Impostate un flag globale ( shock horror ?? !!! ) che dice se c'era un output precedente e lo testate per stampare "Inizializzazione" con un carattere iniziale facoltativo "\ n", oppure producete "\ n" insieme a l'output precedente e lasciare che i futuri lettori di codice si chiedano perché questa "inizializzazione" non ha un "\ n" iniziale come tutti gli altri messaggi di output?

Se si producono costantemente nuove righe finali, nel punto in cui si sa di aver raggiunto la fine della riga che deve essere terminata, si evitano tutti questi problemi. Si noti che ciò potrebbe richiedere un'istruzione put ("\ n") separata alla fine di una logica che emette una riga pezzo per pezzo, ma il punto è che si genera la nuova riga nella prima posizione nel codice in cui si sa che è necessario fallo, non altrove.

Perché usare le nuove righe finali anziché le prime con printf?

Abbina da vicino le specifiche C

La libreria C definisce una riga che termina con un carattere di nuova riga '\n' .

Un flusso di testo è una sequenza ordinata di caratteri composta da righe , ciascuna riga composta da zero o più caratteri più un carattere di nuova riga che termina. Se l'ultima riga richiede un carattere di nuova riga che termina è definita dall'implementazione. C11 §7.21.2 2

Il codice che scrive i dati come linee corrisponderà quindi al concetto di libreria.

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

Ri: l' ultima riga richiede un carattere di nuova riga che termina . Consiglio di scrivere sempre un finale '\n'in uscita e tollerarne l'assenza in ingresso.

Controllo ortografico

Il mio correttore ortografico si lamenta. Forse anche a te.

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

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

Le nuove righe principali possono spesso semplificare la scrittura del codice in presenza di condizionali, ad esempio,

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

(Ma come è stato notato altrove, potrebbe essere necessario svuotare il buffer di output prima di eseguire qualsiasi operazione che richieda molto tempo della CPU.)

Quindi un buon caso può essere fatto per entrambi i modi di farlo, tuttavia personalmente non mi piace printf () e userei una classe personalizzata per costruire l'output.

Le nuove linee principali non funzionano bene con le altre funzioni della libreria, in particolare puts()e perrornella Libreria standard, ma anche con qualsiasi altra libreria che probabilmente utilizzerai.

Se vuoi stampare una riga pre-scritta (una costante o una già formattata - ad es. Con sprintf()), allora puts()è la scelta naturale (ed efficiente). Tuttavia, non è possibile puts()terminare la riga precedente e scrivere una riga non terminata: scrive sempre il terminatore di riga.