Зачем использовать завершающие переводы строк вместо лидирующих с printf?

Я слышал, что при использовании вы должны избегать вводить новые строки printf. Так что вместо printf("\nHello World!")тебя стоит использоватьprintf("Hello World!\n")

В этом конкретном примере выше это не имеет смысла, поскольку выходные данные будут другими, но учтите это:

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

по сравнению с:

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

Я не вижу никакой выгоды от трейлинга новых строк, кроме того, что он выглядит лучше. Есть ли другая причина?

РЕДАКТИРОВАТЬ:

Я обращаюсь к закрытым голосам здесь и сейчас. Я не думаю, что это относится к переполнению стека, потому что этот вопрос в основном касается дизайна. Я хотел бы также сказать , что , хотя это может быть мнение по этому вопросу, ответ Kilian Фот в и ответ cmaster в доказывает , что на самом деле есть очень объективные преимущества с одним подходом.

Достаточное количество терминальных операций ввода-вывода буферизуется строкой , поэтому, заканчивая сообщение \ n, вы можете быть уверены, что оно будет отображаться своевременно. С начальным \ n сообщение может отображаться или не отображаться сразу. Часто это будет означать, что каждый шаг отображает сообщение о ходе выполнения предыдущего шага, что не вызывает путаницы и лишнего времени, когда вы пытаетесь понять поведение программы.

В системах POSIX (в основном в любом Linux, BSD, в любой системе с открытым исходным кодом, которую вы можете найти) строка определяется как строка символов, оканчивающаяся символом новой строки \n. Это основное предположение все стандартные инструменты командной строки опираться, в том числе (но не ограничиваясь ими) wc, grep, sed, awk, и vim. Это также причина, по которой некоторые редакторы (например vim) всегда добавляют \nв конце файла, и почему более ранние стандарты C требовали, чтобы заголовки заканчивались \nсимволом.

Кстати: наличие \nзавершенных строк значительно упрощает обработку текста: вы точно знаете, что у вас есть полная строка, когда у вас есть этот терминатор. И вы точно знаете, что вам нужно смотреть на большее количество символов, если вы еще не сталкивались с этим терминатором.

Конечно, это на стороне ввода программ, но вывод программы очень часто снова используется как ввод программы. Таким образом, ваш вывод должен придерживаться соглашения для обеспечения беспрепятственного ввода в другие программы.

В дополнение к тому, что упомянули другие, я чувствую, что есть гораздо более простая причина: это стандарт. Всякий раз, когда что-либо печатается в STDOUT, оно почти всегда предполагает, что оно уже находится на новой строке, и, следовательно, не нужно начинать новую. Также предполагается, что следующая записываемая строка будет действовать аналогичным образом, поэтому полезно завершить ее, начав новую строку.

Если вы выводите строки, начинающиеся с новой строки, чередующиеся со стандартными строками с конечной новой строкой, «в конечном итоге это будет выглядеть так:

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

... что, по-видимому, не то, что вы хотите.

Если вы используете только начальные символы новой строки в своем коде и запускаете его только в IDE, это может оказаться нормальным. Как только вы запустите его в терминале или введете чужой код, который будет писать в STDOUT вместе с вашим кодом, вы увидите нежелательный вывод, как описано выше.

Поскольку ответы с большим количеством голосов уже дали отличные технические причины, по которым следует отдавать предпочтение завершающим переводам строк, я подойду к этому с другой стороны.

По моему мнению, следующее делает программу более читабельной:

1. высокое отношение сигнал / шум (простое, но не простое)
2. важные идеи на первом месте

Исходя из вышеперечисленных пунктов, мы можем утверждать, что последние строки лучше. Новые строки форматируют «шум» по сравнению с сообщением, сообщение должно выделяться и, следовательно, должно стоять первым (подсветка синтаксиса также может помочь).

Использование завершающих строк новой строки упрощает последующие модификации.

В качестве (очень тривиального) примера, основанного на коде OP, предположим, что вам нужно произвести некоторый вывод перед сообщением «Initializing», и этот вывод происходит из другой логической части кода, в другом исходном файле.

Когда вы запускаете первый тест и обнаруживаете, что «Инициализация» теперь добавляется в конец строки какого-либо другого вывода, вы должны выполнить поиск в коде, чтобы найти, где он был напечатан, и затем надеяться изменить «Инициализация» на «\ nИнициализация». "не портит формат чего-то другого, при других обстоятельствах.

Теперь рассмотрим, как будет обрабатываться тот факт, что ваш новый вывод на самом деле является необязательным, поэтому ваше изменение "\ nInitializing" иногда приводит к появлению нежелательной пустой строки в начале вывода ...

Вы устанавливаете глобальный ( шок ужас ?? !!! ) флаг, указывающий, был ли какой-либо предыдущий вывод, и проверяете его на вывод «Initializing» с необязательным начальным «\ n», или вы выводите «\ n» вместе с ваш предыдущий вывод и будущие читатели кода задаются вопросом, почему эта «Инициализация» не имеет лидирующего «\ n», как все остальные выходные сообщения?

Если вы последовательно выводите завершающие символы новой строки, в точке, в которой вы знаете, что достигли конца строки, которую необходимо завершить, вы обойдете все эти проблемы. Обратите внимание, что для этого может потребоваться отдельный оператор put ("\ n") в конце некоторой логики, которая выводит строку по частям, но дело в том, что вы выводите новую строку в самом раннем месте кода, где вы знаете, что вам нужно сделай это, а не где-нибудь еще.

Зачем использовать завершающие переводы строк вместо лидирующих с printf?

Точно соответствует C spec.

Библиотека C определяет линию как заканчивается с новой строки '\n' .

Текстовый поток - это упорядоченная последовательность символов, состоящая из строк , каждая строка состоит из нуля или более символов плюс завершающий символ новой строки. Требует ли последняя строка завершающего символа новой строки, определяется реализацией. C11 §7.21.2 2

Код, который записывает данные в виде строк, будет соответствовать этой концепции библиотеки.

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: последняя строка требует завершающего символа новой строки . Я бы порекомендовал всегда писать финал '\n'на выходе и терпеть его отсутствие на входе.

Проверка орфографии

Моя проверка орфографии жалуется. Возможно, ты тоже.

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

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

Лидирующие символы новой строки часто облегчают написание кода, когда есть условные выражения, например:

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

(Но, как было отмечено в другом месте, вам может потребоваться очистить буфер вывода перед выполнением каких-либо шагов, которые занимают много времени процессора.)

Следовательно, можно сделать хороший пример для обоих способов сделать это, однако лично мне не нравится printf (), и я использовал бы собственный класс для создания вывода.

Ведущие перевода строки не работают хорошо с другими функциями библиотеки, в частности puts()и perrorв стандартной библиотеке, но и любой другой библиотеки , вы , вероятно, использовать.

Если вы хотите напечатать предварительно написанную строку (либо константу, либо уже отформатированную, например, с помощью sprintf()), то puts()это естественный (и эффективный) выбор. Однако нет возможности puts()завершить предыдущую строку и написать неопределенную строку - она ​​всегда записывает терминатор строки.