Pourquoi utiliser endl quand je peux utiliser un caractère de nouvelle ligne ?

Question

Y a-t-il une raison d'utiliser endl con cout alors que je peux simplement utiliser \n ? Mon livre C++ dit d'utiliser endl, mais je ne vois pas pourquoi. Est-ce que \n pas soutenu aussi largement que endl ou est-ce que je rate quelque chose ?

Answer 1

endl ajoute '\n' au flux et appelle flush() sur le ruisseau. Donc

cout << x << endl;

est équivalent à

cout << x << '\n';
cout.flush();

Un flux peut utiliser un tampon interne qui est réellement diffusé lorsque le flux est purgé. En cas de cout vous ne remarquerez peut-être pas la différence puisqu'elle est en quelque sorte synchronisée ( lié ) avec cin Mais pour un flux arbitraire, comme un flux de fichiers, vous remarquerez une différence dans un programme multithread, par exemple.

Aquí Une discussion intéressante sur les raisons pour lesquelles le rinçage peut être nécessaire.

Answer 2

endl est plus qu'un simple alias pour le \n caractère. Lorsque vous envoyez quelque chose à cout (ou tout autre flux de sortie), il ne traite pas et ne sort pas les données immédiatement. Par exemple :

cout << "Hello, world!";
someFunction();

Dans l'exemple ci-dessus, il y a un peu de la probabilité que l'appel de fonction commence à s'exécuter avant que la sortie ne soit vidée. Utilisation de endl vous forcez la purge à avoir lieu avant l'exécution de la deuxième instruction. Vous pouvez également vous assurer qu'avec l'option ostream::flush fonction.

Answer 3

Endl est une fonction et non un mot-clé.

#include <iostream>
int main()
{
 std::cout<<"Hello World"<<std::endl;  //endl is a function without parenthesis.
 return 0;
}   

Pour comprendre l'image de endl, vous devez d'abord comprendre le sujet "Pointeur vers les fonctions".

Regardez ce code (en C)

#include <stdio.h>
int add(int, int);
int main()
{
   int (*p)(int, int); /*p is a pointer variable which can store the address    
   of a function whose return type is int and which can take 2 int.*/
   int x;

   p=add;                     //Here add is a function without parenthesis.

   x=p(90, 10); /*if G is a variable and Address of G is assigned to p then     
   *p=10 means 10 is assigned to that which p points to, means G=10                        
   similarly x=p(90, 10); this instruction simply says that p points to add    
   function then arguments of p becomes arguments of add i.e add(90, 10)   
   then add function is called and sum is computed.*/  

   printf("Sum is %d", x);
   return 0;
}
int add(int p, int q)
{
  int r;
  r=p+q;
  return r;
}

Compilez ce code et voyez le résultat.

Retour au sujet...

 #include <iostream>
 //using namespace std; 
 int main()
 {
 std::cout<<"Hello World"<<std::endl;
 return 0;
 }

Le fichier iostream est inclus dans ce programme car le prototype de l'objet cout est présent dans le fichier iostream et std est un espace de nom. Il est utilisé parce que la définition (fichiers de bibliothèque) de cout et endl est présente dans l'espace de noms std ; Ou vous pouvez également utiliser "using namespace std" en haut de page, afin de ne pas avoir à écrire "std::coutn<<....." avant chaque cout ou endl.

quand vous écrivez endl sans paranthèse alors vous donnez l'adresse de la fonction endl à cout alors la fonction endl est appelée et la ligne est changée. La raison derrière cela est

namespace endl
{
printf("\n");
}

Conclusion : Derrière le C++, le code du C fonctionne.