Vraag Wat is het verschil tussen cout, cerr, clog van iostream-header in c ++? Wanneer gebruik je welke?


Ik heb geprobeerd het verschil tussen te onderzoeken cout, cerr en clog op internet, maar kon geen perfect antwoord vinden. Ik ben nog steeds niet duidelijk wanneer ik die moet gebruiken. Kan iemand me uitleggen, door middel van eenvoudige programma's en een perfecte situatie illustreren over wanneer om welke te gebruiken?

ik bezocht deze site waarop een klein programma staat cerr en clog, maar de daar verkregen uitvoer kan ook worden verkregen met behulp van cout. Dus ik ben verward over ieders exacte gebruik.


61
2018-05-27 12:04


oorsprong


antwoorden:


stdout en stderr zijn verschillende streams, ook al verwijzen ze beide standaard naar console-uitvoer. Eén van hen (piping) (bijv. program.exe >out.txt) zou de andere niet beïnvloeden.

Over het algemeen, stdout moet worden gebruikt voor de feitelijke uitvoer van het programma, terwijl alle informatie en foutmeldingen moeten worden afgedrukt stderr, zodat als de gebruiker de uitvoer omleidt naar een bestand, informatieberichten nog steeds worden afgedrukt op het scherm en niet op het uitvoerbestand.


39
2018-05-27 12:17



Over het algemeen gebruik je std::cout voor normale uitvoer, std::cerr voor fouten, en std::clog voor "logging" (wat kan betekenen wat je wilt dat het betekent).

Het grote verschil is dat std::cerr is niet gebufferd zoals de andere twee.


In relatie tot de oude C stdout en stderr, std::cout komt overeen met stdout, terwijl std::cerr en std::clog beide komen overeen met stderr (behalve dat std::clog is gebufferd).


83
2018-05-27 12:09



cerr vereist geen buffer, dus het is sneller dan de andere en gebruikt het geheugen niet cout gebruikt, maar omdat cout is gebufferd, in sommige gevallen is het nuttiger. Zo:

  • Gebruik cout voor de standaarduitvoer.
  • Gebruik cerr om fouten te tonen.
  • Gebruik verstoppen voor logging.

9
2018-06-07 15:41



Standaard uitvoerstroom (cout): cout is de instantie van de ostream klasse. cout wordt gebruikt om uitvoer te produceren op het standaard uitvoerapparaat dat meestal het beeldscherm is. De gegevens die moeten worden weergegeven op het scherm worden ingevoegd in de standaard uitvoerstroom (cout) met behulp van de invoegtoepassing (<<).

Un-gebufferde standaard foutstroom (cerr):  cerr is de standaard foutstroom die wordt gebruikt om de fouten uit te voeren. Dit is ook een voorbeeld van de ostream klasse. Als cerr is un-gebufferd dus het wordt gebruikt wanneer we de foutmelding onmiddellijk moeten weergeven. Het heeft geen buffer om het foutbericht op te slaan en later weer te geven.

Gebufferde standaard foutstroom (verstopping): Dit is ook een voorbeeld van ostream klasse en gebruikt om fouten weer te geven, maar in tegenstelling tot cerr de fout wordt eerst ingevoegd in a buffer en wordt opgeslagen in de buffer totdat deze niet volledig is gevuld.

verder lezen: basische input-output-c


6
2017-09-12 06:45



Het verschil tussen deze 3 streams is bufferen.

  1. Met cerr knippert de uitgang
    • onmiddellijk (omdat cerr geen buffer gebruikt).
  2. Met verstopping wordt de uitgang gespuid
    • nadat u uw huidige functie hebt voltooid.
    • expliciet de functie opvullen.
  3. Met cout, spoelt de output
    • nadat u een oproep hebt geplaatst naar alle uitvoerstromen (cout, cerr, clog).
    • nadat u uw huidige functie hebt voltooid.
    • expliciet de functie opvullen.

Controleer de volgende code en voer DEBUG uit via 3 regels: f (std: clog), f (std: cerr), f (std :: out) en open vervolgens 3 uitvoerbestanden om te zien wat er is gebeurd. Je kunt deze 3 lijnen omwisselen om te zien wat er zal gebeuren.

#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";
}

2
2017-11-01 04:47



Uit een standaard C ++ 17-document:

30.4.3 Smalstroomobjecten [narrow.stream.objects]

istream cin;

1 Het object cin regelt de invoer van een stroombuffer die aan het object is gekoppeld stdin, verklaarde in <cstdio> (30.11.1).

2 Na het object cin is geïnitialiseerd, cin.tie() komt terug &cout. De staat is anders hetzelfde als vereist voor basic_ios<char>::init (30.5.5.2).

ostream cout;

3 Het object cout stuurt de uitvoer naar een stroombuffer die aan het object is gekoppeld stdout, verklaarde in <cstdio> (30.11.1).

ostream cerr;

4 Het object cerr stuurt de uitvoer naar een stroombuffer die aan het object is gekoppeld stderr, verklaarde in<cstdio> (30.11.1).

5 Na het object cerr is geïnitialiseerd, cerr.flags() & unitbuf is niet-nul en cerr.tie() komt terug &cout. De staat is anders hetzelfde als vereist voor basic_ios<char>::init (30.5.5.2).

ostream clog;

6 Het object clog stuurt de uitvoer naar een stroombuffer die aan het object is gekoppeld stderr, verklaarde in <cstdio> (30.11.1).

Discussie...

cout schrijft naar stdout; cerr en clog naar stderr

Standaard uit (stdout) is bedoeld om non-error, niet-diagnostische uitvoer van het programma te ontvangen, zoals uitvoer van succesvolle verwerking die kan worden weergegeven aan de eindgebruiker of kan worden gestreamd naar een verdere verwerkingsfase.

Standaardfout (stderr) is bedoeld voor diagnostische uitvoer, zoals waarschuwings- en foutmeldingen die aangeven dat het programma de door de gebruiker verwachte uitvoer niet heeft geproduceerd of niet. Deze invoer kan aan de eindgebruiker worden weergegeven, zelfs als de uitvoergegevens worden doorgesluisd naar een verdere verwerkingsstap.

cin en cerr zijn gebonden aan cout

Ze spoelen allebei door cout voordat u I / O-bewerkingen zelf uitvoert. Dit zorgt ervoor dat vragen worden verzonden naar cout zijn zichtbaar voordat het programma blokkeert om de invoer van te lezen cin, en die eerdere uitvoer naar cout wordt gespoeld voordat een foutmelding wordt geschreven cerr, die de berichten in chronologische volgorde van hun generatie houdt wanneer beide naar dezelfde terminal / bestand / etc worden geleid.

Dit staat in contrast met clog - als u daar schrijft, wordt het niet gebufferd en is het nergens aan gebonden, dus het buffert behoorlijke hoeveelheden logboekregistratie voordat het wordt doorgespoeld. Dit levert de hoogste doorvoer van berichten op, maar dit betekent dat de berichten mogelijk niet snel zichtbaar zijn voor een potentiële consument die de terminal leest of het logbestand verwijdert.


1
2018-02-26 11:28



Beide cout en verstoppen zijn gebufferd maar cerr is niet gebufferd en dit zijn allemaal vooraf gedefinieerde objecten die voorbeelden zijn van klasse ostream. Het basisgebruik van deze drie zijn cout wordt gebruikt voor standaard invoer terwijl verstoppen en cerr wordt gebruikt voor het weergeven van fouten. Het belangrijkste punt waarom cerr is un-gebufferd is mogelijk omdat veronderstel dat u meerdere uitgangen in de buffer hebt en er een foutuitzondering in de code wordt vermeld, dan moet u die fout onmiddellijk weergeven, wat kan worden gedaan door cerr effectief.

Verbeter mij alsjeblieft als ik het fout heb.


0
2017-08-10 14:30



cout wordt meestal gebruikt om sommige instructies op het gebruikersscherm weer te geven. ex- : cout << "Arlene Batada";

output:

Arlene Batada


-2
2017-09-19 14:43