C++ : entrées / sorties (IO)

Enseignement Informatique

LAL

Entrées / sorties à l'écran
- Sorties
- Entrées
Les fichiers
Les flots bufferisés
Les manipulateurs

Sorties à l'écran

Exemple :

 #include <iostream>

 int main()
 {
   std::cout << "Bonjour" << std::endl;
 
   return 0;
 }

Sorties à l'écran

Indispensable pour utiliser
les IO de la STL

 #include <iostream>

 int main()
 {
   std::cout << "Bonjour" << std::endl;
 
   return 0;
 }

Sorties à l'écran

Comme pour tous les composants
de la STL, il faut
toujours se placer dans
l'espace de nommage std

 #include <iostream>

 int main()
 {
   std::cout << "Bonjour" << std::endl;
 
   return 0;
 }

Sorties à l'écran

L'objet std::cout
représente le flot vers l'écran

 #include <iostream>

 int main()
 {
   std::cout << "Bonjour" << std::endl;
 
   return 0;
 }

Sorties à l'écran

L'opérateur << signifie
envoie dans …

 #include <iostream>

 int main()
 {
   std::cout << "Bonjour" << std::endl;
 
   return 0;
 }

Sorties à l'écran

On peut cascader les sorties

 #include <iostream>

 int main()
 {
   std::cout << "Bonjour" << std::endl;
 
   return 0;
 }

Sorties à l'écran

L'objet std::endl effectue 2 opérations :
1. retour chariot
2. vidage du buffer

 #include <iostream>

 int main()
 {
   std::cout << "Bonjour" << std::endl;
 
   return 0;
 }

Sorties

Comment définir l'opérateur << pour une classe :

L'opérateur << est intelligent :
il s'adapte au type de l'objet

 #include <iostream>
 #include <string>

 class A
 {
   friend std::ostream& operator << (std::ostream& s, const A& a)
   { s << "[Un A]"; return (s); }
 };
 
 int main()
 {
   int i = 1;
   float f = (float) 2.3;
   std::string s = "abcd";
   A a;
   std::cout << " i = " << i << " ; f = " << f << std::endl
             << " s = " << s << " ; a = " << a << std::endl;
   return 0;
 }

Sorties

Comment définir l'opérateur << pour une classe :

 > ./exo2.exe
  i = 1 ; f = 2.3 
  s = abcd ; a = [Un A]

 #include <iostream>
 #include <string>

 class A
 {
   friend std::ostream& operator << (std::ostream& s, const A& a)
   { s << "[Un A]"; return (s); }
 };
 
 int main()
 {
   int i = 1;
   float f = (float) 2.3;
   std::string s = "abcd";
   A a;
   std::cout << " i = " << i << " ; f = " << f << std::endl
             << " s = " << s << " ; a = " << a << std::endl;
   return 0;
 }

Entrées du clavier

On utilise
le flot std::cin et l'opérateur >>
qui signifie toujours "envoie dans …"

les entrées en cascade sont séparées par tous les caractères de séparation (espace, tabulation, CR)

 #include <iostream>
 #include <string>

 int main()
 {
   int i = 1;
   double d = 2.3;
   std::string s = "abcd";
   
   std::cin >> i >> d >> std::ws;
   
   std::getline( std::cin, s );
   
   std::cout << "[ " << i
             <<  d   << s << " ]"
             <<  std::endl;

   return 0;
 }

Entrées du clavier

On utilise
le flot std::cin et l'opérateur >>
qui signifie toujours "envoie dans …"

les entrées en cascade sont séparées par tous les caractères de séparation (espace, tabulation, CR)
utilisation d'opérateurs sur les flots
- std::ws saute les séparateurs

 #include <iostream>
 #include <string>

 int main()
 {
   int i = 1;
   double d = 2.3;
   std::string s = "abcd";
   
   std::cin >> i >> d >> std::ws;
   
   std::getline( std::cin, s );
   
   std::cout << "[ " << i
             <<  d   << s << " ]"
             <<  std::endl;

   return 0;
 }

Entrées du clavier

On utilise
le flot std::cin et l'opérateur >>
qui signifie toujours "envoie dans …"

les entrées en cascade sont séparées par tous les caractères de séparation (espace, tabulation, CR)
utilisation d'opérateurs sur les flots
- std::ws saute les séparateurs
pour les chaînes de caractères qui pourraient contenir des séparateurs, il faut analyser soi-même les lignes

 #include <iostream>
 #include <string>

 int main()
 {
   int i = 1;
   double d = 2.3;
   std::string s = "abcd";
   
   std::cin >> i >> d >> std::ws;
   
   std::getline( std::cin, s );
   
   std::cout << "[ " << i
             <<  d   << s << " ]"
             <<  std::endl;

   return 0;
 }

Entrées du clavier

 > ./exo3.exe
 [ 12.3abcd ]

 #include <iostream>
 #include <string>

 int main()
 {
   int i = 1;
   double d = 2.3;
   std::string s = "abcd";
   
   std::cin >> i >> d >> std::ws;
   
   std::getline( std::cin, s );
   
   std::cout << "[ " << i
             <<  d   << s << " ]"
             <<  std::endl;

   return 0;
 }

Les fichiers

On utilise
- les flots std::ifstream et std::ofstream
- les opérateurs << et >>

 #include <fstream>
 #include <string>

 int main()
 {
   int i = 1;
   double d = 2.3;
   std::string s = "abcd efgh";
   
   std::ofstream f( "fichier.txt" );
   
   if (f.is_open())
   {
     f << i << " " << d << std::endl;
     f << s << std::endl;
     f.close();
   }
   return 0;
 }

Les fichiers

On utilise
- les flots std::ifstream et std::ofstream
- les opérateurs << et >>
Ouverture d'un fichier

 #include <fstream>
 #include <string>

 int main()
 {
   int i = 1;
   double d = 2.3;
   std::string s = "abcd efgh";
   
   std::ofstream f( "fichier.txt" );
   
   if (f.is_open())
   {
     f << i << " " << d << std::endl;
     f << s << std::endl;
     f.close();
   }
   return 0;
 }

Les fichiers

On utilise
- les flots std::ifstream et std::ofstream
- les opérateurs << et >>
Ouverture d'un fichier
Écriture

 #include <fstream>
 #include <string>

 int main()
 {
   int i = 1;
   double d = 2.3;
   std::string s = "abcd efgh";
   
   std::ofstream f( "fichier.txt" );
   
   if (f.is_open())
   {
     f << i << " " << d << std::endl;
     f << s << std::endl;
     f.close();
   }
   return 0;
 }

Les fichiers

On utilise
- les flots std::ifstream et std::ofstream
- les opérateurs << et >>
Ouverture d'un fichier
Écriture
Fermeture
- obligatoire :
  le destructure du flot ne ferme pas le fichier

 #include <fstream>
 #include <string>

 int main()
 {
   int i = 1;
   double d = 2.3;
   std::string s = "abcd efgh";
   
   std::ofstream f( "fichier.txt" );
   
   if (f.is_open())
   {
     f << i << " " << d << std::endl;
     f << s << std::endl;
     f.close();
   }
   return 0;
 }

Les fichiers (suite)

Lecture
- toujours tester la fin de fichier

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

 int main()
 {
   int i;
   double d;
   std::string s;
   
   std::ifstream f( "fichier.txt" );
   
   if (f.is_open())
   {
     if (!f.eof()) f >> i;
     if (!f.eof()) f >> d;
     if (!f.eof()) f >> std::ws;
     if (!f.eof()) std::getline( f, s );
     f.close();
   }
   std::cout << "[ " << i
             << d << s << " ]"
             << std::endl;
   return 0;
 }

Les fichiers (suite)

Lecture
- toujours tester la fin de fichier
- en général, il est nécessaire de traiter la syntaxe manuellement, après lecture ligne à ligne des entrées

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

 int main()
 {
   int i;
   double d;
   std::string s;
   
   std::ifstream f( "fichier.txt" );
   
   if (f.is_open())
   {
     if (!f.eof()) f >> i;
     if (!f.eof()) f >> d;
     if (!f.eof()) f >> std::ws;
     if (!f.eof()) std::getline( f, s );
     f.close();
   }
   std::cout << "[ " << i
             << d << s << " ]"
             << std::endl;
   return 0;
 }

Les flots bufferisés

Utilise les flots std::istringstream et std::ostringstream et les opérateurs << et >>
- toutes les opérations s'effectuent dans un std::string dynamique
- on peut convertir ces flots en std::string
  - par le constructeur
  - par la fonction str()

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

 int main()
 {
   int i;
   double d;
   std::string s;
   
   std::string input = "123 1.23 abcd def";
   
   std::istringstream b (input);
   b >> i >> d >> std::ws;
   std::getline( b, s );
   
   std::cout << "[ " << std::hex << i
             << d << s << " ]"
             << std::endl;
   return 0;
 }

Les manipulateurs

Injectent des modifications de comportement sur les flots

boolalpha	Formatte les valeurs booléennes avec true et false
dec	Format décimal pour les valeurs entières
fixed	Format en virgule fixe (sans exposant)
hex	Format hexadécimal
internal	Complète une valeur numérique avec des caractères de remplissage en position interne
left	Complète une valeur numérique avec des caractères de remplissage à la fin
oct	Format octal
right	Complète une valeur numérique avec des caractères de remplissage au début
scientific	Format scientifique (avec exposnt)
showbase	Montre la base numérique en préfixe
showpoint	Force l'affichage du point en format scientifique
showpos	Force l'affichage du signe +
skipws	Saute les espaces avant certaines opérations
unitbuf	Vide le buffer avant toute sortie
uppercase	Force les majuscules dans certaines opérations

 int i = 1234;
 std::cout << hex << i << std::endl;

Questions ?