Por que usar novas linhas à direita em vez de liderar com printf?

Ouvi dizer que você deve evitar liderar novas linhas ao usar printf. Para que, em vez de printf("\nHello World!")você, useprintf("Hello World!\n")

Neste exemplo em particular acima, não faz sentido, pois a saída seria diferente, mas considere isso:

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

comparado com:

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

Não vejo nenhum benefício em seguir as novas linhas, exceto que parece melhor. Existe algum outro motivo?

EDITAR:

Vou abordar os votos próximos aqui e agora. Eu não acho que isso pertença ao estouro de pilha, porque esta pergunta é principalmente sobre design. Também gostaria de dizer que, embora possa ser opiniões a este assunto, a resposta de Kilian Foth e resposta de cmaster prova que há de fato benefícios muito objetivas com uma abordagem.

Uma quantidade razoável de E / S do terminal é armazenada em buffer de linha ; portanto, encerrando uma mensagem com \ n, você pode ter certeza de que ela será exibida em tempo hábil. Com um \ n inicial, a mensagem pode ou não ser exibida de uma só vez. Freqüentemente, isso significa que cada etapa exibe a mensagem de progresso da etapa anterior , o que não causa confusão e desperdiça tempo ao tentar entender o comportamento de um programa.

Nos sistemas POSIX (basicamente qualquer linux, BSD, qualquer sistema baseado em código aberto que você puder encontrar), uma linha é definida como uma sequência de caracteres terminados por uma nova linha \n. Este é o pressuposto básico de todas as ferramentas de linha de comando padrão construir em cima, incluindo (mas não limitado a) wc, grep, sed, awk, e vim. Essa também é a razão pela qual algum editor (como vim) sempre adiciona um \nno final de um arquivo e por que os padrões anteriores de C exigiam que os cabeçalhos terminassem com um \ncaractere.

Btw: Ter \nlinhas finalizadas facilita muito o processamento de texto: você tem certeza de que possui uma linha completa quando possui esse terminador. E você tem certeza de que precisa procurar mais personagens se ainda não encontrou esse terminador.

Obviamente, isso ocorre no lado de entrada dos programas, mas a saída do programa é frequentemente usada como entrada de programa novamente. Portanto, sua saída deve seguir a convenção, a fim de permitir uma entrada direta em outros programas.

Além do que outros já mencionaram, sinto que há uma razão muito mais simples: é o padrão. Sempre que algo é impresso em STDOUT, quase sempre assume que ele já está em uma nova linha e, portanto, não precisa iniciar uma nova. Ele também pressupõe que a próxima linha a ser escrita funcionará da mesma maneira e, portanto, termina de maneira útil iniciando uma nova linha.

Se você produzir linhas de linha de frente principais entrelaçadas com linhas de linha de fuga à linha padrão ", ela terá a seguinte aparência:

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

... o que presumivelmente não é o que você deseja.

Se você usar apenas as novas linhas principais no seu código e executá-lo apenas em um IDE, pode ser que isso aconteça. Assim que você executá-lo em um terminal ou introduzir o código de outras pessoas que gravará no STDOUT ao lado do seu código, você verá resultados indesejáveis, como acima.

Como as respostas altamente votadas já deram excelentes razões técnicas pelas quais as novas linhas finais devem ser preferidas, abordarei isso de outro ângulo.

Na minha opinião, os itens a seguir tornam um programa mais legível:

1. uma alta relação sinal / ruído (também conhecida como simples, mas não mais simples)
2. idéias importantes vêm em primeiro lugar

Pelos pontos acima, podemos argumentar que as novas linhas à direita são melhores. As novas linhas estão formatando "ruído" quando comparadas à mensagem, a mensagem deve se destacar e, portanto, deve vir em primeiro lugar (o destaque da sintaxe também pode ajudar).

O uso de novas linhas finais simplifica as modificações posteriores.

Como um exemplo (muito trivial) baseado no código do OP, suponha que você precise produzir alguma saída antes da mensagem "Inicializando", e essa saída venha de uma parte lógica diferente do código, em um arquivo de origem diferente.

Quando você executa o primeiro teste e descobre que "Inicializando" agora é anexado ao final de uma linha de alguma outra saída, você precisa pesquisar o código para descobrir onde ele foi impresso e depois esperar alterar "Inicializando" para "\ nInicializar "não estraga o formato de outra coisa, em circunstâncias diferentes.

Agora, considere como lidar com o fato de que sua nova saída é realmente opcional; portanto, sua alteração em "\ nInicialização" às vezes produz uma linha em branco indesejada no início da saída ...

Você define um sinalizador global ( horror de choque ?? !!! ) dizendo se havia alguma saída anterior e o testa para imprimir "Inicializando" com um \ n "\ n" inicial opcional, ou você gera o "\ n" junto com sua saída anterior e deixar futuros leitores de código se perguntando por que essa "Inicialização" não tem um \ n "\ n" à esquerda, como todas as outras mensagens de saída?

Se você produzir consistentemente novas linhas finais, no ponto em que você sabe que atingiu o final da linha que precisa ser encerrada, evite todos esses problemas. Observe que isso pode exigir uma declaração de puts separada ("\ n") no final de alguma lógica que produza uma linha peça por peça, mas o ponto é que você gera a nova linha no primeiro local do código em que você sabe que precisa faça isso, não em outro lugar.

Por que usar novas linhas à direita em vez de liderar com printf?

Corresponder de perto à especificação C.

A biblioteca C define uma linha como terminando com um caractere de nova linha '\n' .

Um fluxo de texto é uma sequência ordenada de caracteres compostos em linhas , cada linha consistindo em zero ou mais caracteres mais um caractere de nova linha final. Se a última linha requer um caractere de nova linha final é definida pela implementação. C11 §7.21.2 2

O código que grava dados como linhas corresponderá a esse conceito de 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: última linha requer um caractere de nova linha final . Eu recomendo sempre escrever uma final '\n'na saída e tolerar sua ausência na entrada.

Verificação ortográfica

Meu verificador ortográfico reclama. Talvez o seu também.

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

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

As novas linhas principais geralmente tornam mais fácil escrever o código quando há condicionais, por exemplo,

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

(Mas, como foi observado em outro lugar, pode ser necessário liberar o buffer de saída antes de executar as etapas que levam muito tempo na CPU.)

Portanto, um bom argumento pode ser feito para as duas formas de fazê-lo, por mais que eu pessoalmente não goste de printf () e usaria uma classe personalizada para criar a saída.

Novas linhas principais não funcionam bem com outras funções de biblioteca, nomeadamente puts()e perrorna biblioteca padrão, mas também qualquer outra biblioteca é provável que você usar.

Se você deseja imprimir uma linha pré-escrita (constante, ou já formatada - por exemplo, com sprintf()), então puts()é a opção natural (e eficiente). No entanto, não há como puts()terminar a linha anterior e escrever uma linha não terminada - ela sempre grava o terminador da linha.