В чем разница между cout, cerr, clog заголовка iostream в С++? Когда использовать какой?

Я попытался изучить разницу между cout, cerr и clog в Интернете, но не смог найти идеального ответа. Я все еще не понимаю, когда использовать. Может ли кто-нибудь объяснить мне, через простые программы и проиллюстрировать идеальную ситуацию, когда использовать какой?

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

Ответ 1

stdout и stderr - это разные потоки, хотя они по умолчанию ссылаются на вывод консоли. Перенаправление (передача) одного из них (например, program.exe >out.txt) не повлияет на другое.

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

Ответ 2

Обычно вы используете std::cout для нормального вывода, std::cerr для ошибок и std::clog для "ведения журнала" (что может означать то, что вы хотите, чтобы оно означало).

Основное отличие состоит в том, что std::cerr не буферизуется, как два других.

В отношении старых C stdout и stderr, std::cout соответствует stdout, а std::cerr и std::clog оба соответствуют stderr (за исключением того, что std::clog буферизуется).

Ответ 3

Используйте cout для стандартного вывода.
Используйте cerr для отображения ошибок.
Используйте засорение для регистрации.

Ответ 4

Стандартный поток вывода (cout): cout является экземпляром класса ostream. cout используется для вывода на стандартное устройство вывода, которым обычно является экран дисплея. Данные, которые необходимо отобразить на экране, вставляются в стандартный поток вывода (cout) с помощью оператора вставки (<<).

Стандартный поток ошибок без буферизации (cerr): cerr - стандартный поток ошибок, который используется для вывода ошибок. Это также экземпляр класса ostream. Поскольку cerr небуферизован, он используется, когда нам нужно немедленно отобразить сообщение об ошибке. У него нет буфера для хранения сообщения об ошибке и отображения позже.

Буферизованный стандартный поток ошибок (clog): это также экземпляр класса ostream используется для отображения ошибок, но в отличие от cerr ошибка сначала вставляется в буфер и сохраняется в буфере до тех пор, пока он не будет заполнен полностью.

дальнейшее чтение: basic-input-output-c

Ответ 5

Разница этих трех потоков буферизуется.

С помощью cerr выходные флеши
- немедленно (потому что cerr не использует буфер).
С забиванием выходные флеши
- после завершения текущей функции.
- явно вызывает функцию flush.
С помощью cout выходные потоки
- после вызова любых выходных потоков (cout, cerr, clog).
- после завершения текущей функции.
- явно вызывает функцию flush.

Пожалуйста, проверьте следующий код и запустите DEBUG через 3 строки: f (std:: clog), f (std:: cerr), f (std:: out), затем откройте 3 выходных файла, чтобы узнать, что произошло. Вы можете поменять эти 3 строки, чтобы увидеть, что произойдет.

#include <iostream>
#include <fstream>
#include <string>

void f(std::ostream &os)
{
    std::cin.clear(); // clear EOF flags
    std::cin.seekg(0, std::cin.beg); // seek to begin

    std::string line;
    while(std::getline(std::cin, line))   //input from the file in.txt
        os << line << "\n";   //output to the file out.txt
}

void test()
{
    std::ifstream in("in.txt");
    std::ofstream out("out.txt"), err("err.txt"), log("log.txt");
    std::streambuf *cinbuf = std::cin.rdbuf(), *coutbuf = std::cout.rdbuf(), *cerrbuf = std::cerr.rdbuf(),
                    *clogbuf = std::clog.rdbuf();

    std::cin.rdbuf(in.rdbuf()); //redirect std::cin to in.txt!
    std::cout.rdbuf(out.rdbuf()); //redirect std::cout to out.txt!
    std::cerr.rdbuf(err.rdbuf());
    std::clog.rdbuf(log.rdbuf());


    f(std::clog);
    f(std::cerr);
    f(std::cout);

    std::cin.rdbuf(cinbuf);
    std::cout.rdbuf(coutbuf);
    std::cerr.rdbuf(cerrbuf);
    std::clog.rdbuf(clogbuf);
}

int main()
{
    test();
    std::cout << "123";
}

Ответ 6

Из черновика стандартного документа С++ 17:

30.4.3 Объекты с узким потоком [thin.stream.objects]

istream cin;

1 Объект cin управляет вводом из буфера потока, связанного с объектом stdin, объявленным в <cstdio> (30.11.1).

2 После инициализации объекта cin cin.tie() возвращает &cout. В остальном его состояние такое же, как требуется для basic_ios<char>::init (30.5.5.2).

ostream cout;

3 Объект cout управляет выводом в буфер потока, связанный с объектом stdout, объявленным в <cstdio> (30.11.1).

ostream cerr;

4 Объект cerr управляет выводом в буфер потока, связанный с объектом stderr, объявленным в <cstdio> (30.11.1).

5 После того как объект cerr инициализируется, cerr.flags() & unitbuf отлична от нуля и cerr.tie() возвращает &cout. В остальном его состояние такое же, как требуется для basic_ios<char>::init (30.5.5.2).

ostream clog;

6 Объект clog управляет выводом в буфер потока, связанный с объектом stderr, объявленным в <cstdio> (30.11.1).

Обсуждение...

cout пишет в stdout ; cerr и clog к stderr

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

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

cin и cerr привязаны к cout

Они оба сбрасывают cout перед выполнением операций ввода-вывода сами. Это гарантирует, что запросы, отправленные в cout будут видны до того, как блоки программы прочитают ввод из cin, и что более ранний вывод в cout сбрасывается перед записью ошибки через cerr, который сохраняет сообщения в хронологическом порядке их генерации, когда оба они направлены на одно и то же. терминал/файл/и т.д..

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

Ответ 7

Оба cout и clog буферизуются, но cerr не забуферированы, и все они являются предопределенными объектами, которые являются экземплярами класса ostream. Основное использование этих трех cout используется для стандартного ввода, тогда как clog и cerr используется для отображения ошибок. Основной вопрос, почему cerr не забуферирован, может быть, потому что предположим, что в буфере есть несколько выходов, а в коде указано исключение ошибки, тогда вам нужно немедленно отобразить эту ошибку, которая может быть выполнена cerr.

Пожалуйста, поправьте меня, если я ошибаюсь.

Ответ 8

cout обычно используется для отображения некоторых инструкций на экране пользователя. экс- : cout < "Arlene Batada";

выход:

Арлин Батада