Programmation C++/Les entrées-sorties

Programmation C++

• Avant-propos
• Introduction
• Compilation
• Un premier programme
• Les commentaires
• Le préprocesseur
• Les types de base et les déclarations
  • Exercices
• Les opérations de base
• Les entrées-sorties
• Les pointeurs
  • Exercices
• Les références
• Les tableaux
  • Exercices
  • Exercices sur les tableaux statiques
  • Exercice : Tris des tableaux à une dimension
  • Solution : Tris des tableaux à une dimension
• Les structures de contrôle
  • Exercices
  • Exercices if...else et switch
• Les fonctions
  • Exercices
• Les structures
  • Exercices
• Les classes
  • Exercices
  • Exercices de développement
• Les espaces de noms
• Les exceptions
• Les templates
  • Exercices
• Conventions d'appel
• Les fichiers
• La librairie standard
• Expressions rationnelles
• Interfaces graphiques
• Bibliographie et liens

Annexes

• Dessiner des formes : les bibliothèques graphiques

Anciennes pages

• Opérateurs
• Héritage
• Polymorphisme

Classes de gestion des flux

Les entrées et sorties sont gérées par deux classes définies dans le fichier d'en-tête <iostream> :

• ostream (Output stream) permet d'écrire des données vers la console, un fichier, ... Cette classe surdéfinit l'opérateur <<.
• istream (Input stream) permet de lire des données à partir de la console, d'un fichier, ... Cette classe surdéfinit l'opérateur >>.

Flux standards

Trois instances de ces classes représentent les flux standards :

• cout écrit vers la sortie standard,
• cerr écrit vers la sortie d'erreur,
• clog écrit vers la sortie technique,
• cin lit à partir de l'entrée standard (jusqu'au premier espace exclu, éventuellement). Demander un nombre et y entrer des lettres provoque une erreur.
• getline lit à partir de l'entrée standard (tout).

Ces objets sont définis dans l'espace de nom std.

Exemple

#include <iostream>

using namespace std;
 
int main()
{
    int n;
    cout << "Entrez un nombre positif : ";
    cin >> n;
    if (n<0) cerr << "Erreur: Le nombre " << n
                  << " n'est pas positif " << endl;
    else cout << "Vous avez entré " << n << endl;
    return 0;
}

Autres types de flux

Les instances des classes dérivées des classes istream et ostream sont également manipulés avec les opérateurs << et >>. Cependant, il ne faut pas oublier de les fermer en appelant la méthode close().

Note: Les noms de fichiers sont codés sur 8 bits sous Linux/Unix et sur 16 bits sur Windows, ce qui peut induire des problèmes de portabilité, le cas échéant.

Flux de fichier

La classe ifstream permet de lire à partir d'un fichier. Le constructeur a la syntaxe suivante :

ifstream(const char* filename, openmode mode=in)

Le paramètre mode peut être une combinaison des valeurs suivantes :

app

(append) Placer le curseur à la fin du fichier avant écriture.

ate

(at end) Placer le curseur à la fin du fichier.

binary

Ouvrir en mode binaire plutôt que texte.

in

Autoriser la lecture.

out

Autoriser l'écriture.

trunc

(truncate) Tronquer le fichier à une taille nulle.

Exemple 1 : lire un entier depuis un fichier

ifstream fichier("test.txt");
int a;
fichier >> a; // lire un entier
cout << "A = " << a;
fichier.close();

Exemple 2 : afficher tous les caractères d'un fichier

ifstream fichier("test.txt");
while (fichier.good())
    cout << (char) fichier.get();
fichier.close();

La classe ofstream permet d'écrire vers un fichier. Son constructeur a une syntaxe similaire :

ofstream(const char* filename, openmode mode=out|trunc)

Exemple :

ofstream fichier("test.txt");
fichier << setw(10) << a << endl;
fichier.close();

La classe fstream dérive de la classe iostream permettant à la fois la lecture et l'écriture. Cette dernière (iostream) dérive donc à la fois de la classe ostream et de la classe istream. Son constructeur a la syntaxe suivante :

fstream(const char* filename, openmode mode=in|out)

Exemple :

fstream fichier("test.txt");
fichier << setw(10) << a << endl;
fichier.seekg(0, ios_base::beg);
fichier >> b;
fichier.close();

Flux de chaîne de caractères

Ces flux permettent d'écrire pour produire une chaîne de caractères, ou de lire à partir d'une chaîne de caractères.

La classe istringstream dérivée de istream permet de lire à partir d'une chaîne de caractères, et possède deux constructeurs :

istringstream ( openmode mode = in );
istringstream ( const string & str, openmode mode = in );

Exemple :

int n, val;
string stringvalues;
stringvalues = "125 320 512 750 333";
istringstream iss (stringvalues, istringstream::in);

for (n = 0; n < 5; n++)
{
    iss >> val;
    cout << val << endl;
}

La classe ostringstream dérivée de ostream permet d'écrire pour créer une chaîne de caractères, et possède également deux constructeurs :

ostringstream ( openmode mode = out );
ostringstream ( const string & str, openmode mode = out );

Le second permet de spécifier le début de la chaîne de caractères produite.

La méthode str() retourne la chaîne de caractères produite.

Exemple :

ostringstream oss (ostringstream::out);
int a = 100;
oss << "Test d'écriture a=" << a << "\n";
cout << oss.str();

La classe stringstream dérivée de iostream permet d'écrire et lire, et possède deux constructeurs :

stringstream ( openmode mode = in | out );
stringstream ( const string & str, openmode mode = in | out );

Exemple :

int n, val;
stringstream ss (stringstream::in | stringstream::out);

// écriture
ss << "120 42 377 6 5 2000";

// lecture
for (int n = 0; n < 6; n++)
{
    ss >> val;
    cout << val << endl;
}

Manipulateurs

Le fichier d'en-tête <iomanip> définit des manipulateurs de flux tels que endl, hex. Ces manipulateurs modifient la façon d'écrire ou lire les données qui suivent celui-ci.

Manipulateur endl

Ce manipulateur écrit un retour à la ligne dans le flux, quel qu'il soit (\r\n pour Windows, \n pour Unix/Linux, \r pour Mac, ...). Il est donc conseillé de l'utiliser au lieu du/des caractère(s) correspondant(s), si la portabilité de votre application joue un rôle important.

Exemple:

cout << "Une première ligne" << endl << "Une deuxième ligne" << endl;

N.B.: Certains compilateurs C++ (notamment Visual C++) ne supporte pas que le manipulateur endl soit suivi d'autres données à écrire. Dans ce cas, il faut écrire les données suivantes dans une nouvelle instruction :

cout << "Une première ligne" << endl;
cout << "Une deuxième ligne" << endl;

Manipulateur hex

Ce manipulateur indique que les prochains entiers sont à lire ou écrire en base hexadécimale.

Manipulateur dec

Ce manipulateur indique que les prochains entiers sont à lire ou écrire en base décimale.

Manipulateur setbase(base)

Les 2 manipulateurs précédents sont des alias de celui-ci, qui permet de spécifier la base des prochains entiers à lire ou écrire.

Exemple :

int a = 200; // 200 en décimal

cout << "Valeur de a en base 16 = " << setbase(16) << a << endl;
// affiche:  Valeur de a en base 16 = C8

cout << "Valeur de a en base 10 = " << setbase(10) << a << endl;
// affiche:  Valeur de a en base 10 = 200

cout << "Valeur de a en base 8 = " << setbase(8) << a << endl;
// affiche:  Valeur de a en base 8 = 310

Manipulateur setw(width)

Ce manipulateur indique que les prochaines données doivent être écrites sur le nombre de caractères indiqué, en ajoutant des caractères espaces avant.

Exemple :

int a = 11;
cout << "Valeur de a = " << setw(5) << a << endl;

Ce code affiche :

Valeur de a =    11

Manipulateur setfill(char)

Ce manipulateur modifie le caractère utilisé pour compléter les données utilisant le manipulateur setw.

Exemple :

int a = 11;
cout << "Valeur de a = " << setfill('x') << setw(5) << a << endl;

Ce code affiche :

Valeur de a = xxx11

Manipulateur setprecision(digits)

Ce manipulateur spécifie que les prochains nombres à virgule flottante doivent être écrits avec la précision donnée. La précision donne le nombre maximum de chiffres à écrire (avant et après la virgule).

Exemple :

double f = 3.14159;
cout << setprecision (5) << f << endl;
cout << setprecision (9) << f << endl;

Ce code affiche :

3.1416
3.14159

Manipulateurs setiosflags et resetiosflags

Le manipulateur setiosflags (resp. resetiosflags) active (resp. désactive) des options de format des données.

Ces deux manipulateurs possèdent un argument dont le type est défini par l'énumération ios_base::fmtflags. Cet argument peut être :

ios_base::boolalpha

Ecrire/lire les données de type bool sous forme textuelle, càd true ou false.

ios_base::oct

Ecrire/lire les entiers en base octale (base 8).

ios_base::dec

Ecrire/lire les entiers en base décimale (base 10).

ios_base::hex

Ecrire/lire les entiers en base hexadécimale (base 16).

ios_base::showbase

Faire précéder les entiers par leur base.

ios_base::showpos

Faire précéder les nombres positifs du signe plus ( + ).

ios_base::showpoint

Toujours écrire la virgule des nombres réels.

ios_base::fixed

Ecrire les nombres réels avec une virgule fixe.

ios_base::scientific

Ecrire les nombres réels sous forme scientifique.

ios_base::left

Aligner les donnés à gauche (setw).

ios_base::right

Aligner les donnés à droite (setw).

ios_base::internal

Aligner les donnés en remplissant à une position interne (setw).

ios_base::skipws

Ignorer les caractères blancs avant de lire les données.

ios_base::unitbuf

Vider le buffer de sortie à chaque écriture.

ios_base::uppercase

Ecrire les données en majuscules.

Cette section est vide, pas assez détaillée ou incomplète.