Quelle est la différence entre cout, cerr, clog de l’en-tête iostream dans c ++? Quand utiliser lequel?

J’ai essayé de rechercher la différence entre cout , cerr et cerr sur internet, mais je n’ai pas trouvé de réponse parfaite. Je ne sais toujours pas quand utiliser quoi. Est-ce que n’importe qui peut m’expliquer, à travers des programmes simples et illustrer une situation parfaite sur quand employer lequel?

J’ai visité ce site qui montre un petit programme sur cerr et cerr , mais le résultat obtenu peut également être obtenu en utilisant cout . Donc, je suis confus quant à l’utilisation exacte de chacun.

stdout et stderr sont des stream différents, même s’ils font tous deux référence à la sortie de la console par défaut. La redirection de l’un d’entre eux (par exemple, program.exe >out.txt ) n’affecterait pas l’autre.

En général, stdout doit être utilisé pour la sortie réelle du programme, alors que toutes les informations et les messages d’erreur doivent être imprimés sur stderr , de sorte que si l’utilisateur redirige la sortie vers un fichier, les messages d’information sont toujours imprimés sur l’écran.

En général, vous utilisez std::cout pour une sortie normale, std::cerr pour les erreurs et std::clog pour “logging” (ce qui peut vouloir dire tout ce que vous voulez dire).

La principale différence est que std::cerr n’est pas mis en mémoire tampon comme les deux autres.


En ce qui concerne les anciens stdout et stderr , std::cout correspond à stdout , alors que std::cerr et std::clog std::cerr correspondent tous deux à stderr (sauf que std::clog est mis en mémoire tampon).

cerr ne nécessite pas de tampon, il est donc plus rapide que les autres et n’utilise pas la mémoire utilisée par cout , mais parce que cout est mis en mémoire tampon, il est plus utile dans certains cas. Alors:

  • Utilisez cout pour la sortie standard.
  • Utilisez cerr pour afficher les erreurs.
  • Utilisez le sabot pour la journalisation.

Flux de sortie standard (cout): cout est l’instance de la classe ostream . cout est utilisé pour produire une sortie sur le périphérique de sortie standard qui est généralement l’écran d’affichage. Les données à afficher à l’écran sont insérées dans le stream de sortie standard ( cout ) à l’aide de l’opérateur d’insertion ( << ).

Flux d'erreur standard sans tampon (cerr): cerr est le stream d'erreur standard utilisé pour générer les erreurs. C'est aussi une instance de la classe ostream . Comme cerr n'est pas mis en mémoire tampon , il est utilisé lorsque nous devons afficher le message d'erreur immédiatement. Il n'a pas de tampon pour stocker le message d'erreur et l'afficher plus tard.

Flux d'erreur standard en mémoire tampon (clog): il s'agit également d'une instance de la classe ostream et utilisée pour afficher des erreurs, mais contrairement à cerr l'erreur est d'abord insérée dans un tampon jusqu'à ce qu'elle ne soit pas complètement remplie.

Lectures complémentaires: basic-input-output-c

La différence de ces 3 stream est la mise en mémoire tampon.

  1. Avec cerr, la sortie chasse
    • immédiatement (car cerr n’utilise pas de tampon).
  2. Avec le sabot, la sortie roule
    • après avoir terminé votre fonction actuelle.
    • appeler explicitement la fonction flush.
  3. Avec cout, la sortie coule à flot
    • après avoir appelé des stream de sortie (cout, cerr, clog).
    • après avoir terminé votre fonction actuelle.
    • appeler explicitement la fonction flush.

Veuillez vérifier le code suivant et exécutez DEBUG via 3 lignes: f (std :: clog), f (std :: cerr), f (std :: out), puis ouvrez 3 fichiers de sortie pour voir ce qui s’est passé. Vous pouvez échanger ces 3 lignes pour voir ce qui va se passer.

 #include  #include  #include  void f(std::ostream &os) { std::cin.clear(); // clear EOF flags std::cin.seekg(0, std::cin.beg); // seek to begin std::ssortingng 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"; } 

A partir d’un brouillon de document standard C ++ 17:

30.4.3 Objets de stream étroit [narrow.stream.objects]

istream cin;

1 L’object cin contrôle les entrées d’un tampon de stream associé à l’object stdin , déclaré dans (30.11.1).

2 Une fois l’object cin initialisé, cin.tie() renvoie &cout . Son état est le même que celui requirejs pour basic_ios::init (30.5.5.2).

ostream cout;

3 Le cout object contrôle la sortie vers un tampon de stream associé à l’object stdout , déclaré dans (30.11.1).

ostream cerr;

4 L’object cerr contrôle la sortie vers un tampon de stream associé à l’object stderr , déclaré dans (30.11.1).

5 Une fois l’object cerr initialisé, cerr.flags() & unitbuf est différent de zéro et cerr.tie() renvoie &cout . Son état est le même que celui requirejs pour basic_ios::init (30.5.5.2).

ostream clog;

6 L’object clog contrôles de sortie vers un tampon de stream associé à l’object stderr , déclaré dans (30.11.1).

Discussion…

cout écrit dans stdout ; cerr et clog à stderr

La sortie standard ( stdout ) est destinée à recevoir une sortie sans erreur et sans diagnostic du programme, telle que la sortie d’un traitement réussi pouvant être affichée à l’utilisateur final ou diffusée dans une étape de traitement ultérieure.

Erreur standard ( stderr ) est destiné à la sortie de diagnostic, telle que les messages d’avertissement et d’erreur indiquant que le programme n’a pas ou n’a pas généré la sortie attendue par l’utilisateur. Cette entrée peut être affichée à l’utilisateur final même si les données de sortie sont acheminées vers une autre étape de traitement.

cin et cerr sont liés à cout

Ils cout tous les deux avant de manipuler eux-mêmes les opérations d’E / S. Cela garantit que les invites envoyées à cout sont visibles avant que le programme ne bloque l’entrée de cin et que la sortie précédente vers cout soit vidée avant d’écrire une erreur via cerr , ce qui conserve les messages dans leur ordre chronologique. terminal / fichier / etc ..

Cela contraste avec le clog – si vous écrivez là-bas, il ne sera pas mis en mémoire tampon et ne sera lié à rien, il tamponnera donc des quantités de taille décente avant de les vider. Cela donne le plus haut débit de messages, mais cela signifie que les consommateurs ne peuvent pas voir rapidement les messages en train de lire le terminal ou de suivre le journal.

Cout et clog sont tous deux mis en mémoire tampon, mais cerr n’est pas tamponné et tous sont des objects prédéfinis qui sont des instances de la classe ostream. L’usage de base de ces trois termes est cout est utilisé pour l’entrée standard, alors que le code clog et cerr sont utilisés pour afficher les erreurs. Le point principal pour lequel cerr est non tamponné est peut-être parce que supposons que vous ayez plusieurs sorties dans le tampon et qu’une exception d’erreur est mentionnée dans le code.

S’il vous plait corrigez moi si je me trompe.

cout est généralement utilisé pour afficher certaines déclarations sur l’écran de l’utilisateur. ex-: cout << "Arlene Batada";

sortie:

Arlene Batada