# Programmation C++/Les entrées-sorties

* 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

## Anciennes pages

* Opérateurs
* Héritage
* Polymorphisme
* 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

## Anciennes pages

* Opérateurs
* Héritage
* Polymorphisme
[ Modifier le sommaire ]

## 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
## 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 :
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
Exemple 2 : afficher tous les caractères d'un fichier
La classe ofstream permet d'écrire vers un fichier. Son constructeur a une syntaxe similaire :
Exemple :
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 :
Exemple :

### 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 :
Exemple :
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 :
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 :
La classe stringstream dérivée de iostream permet d'écrire et lire, et possède deux constructeurs :
Exemple :

## 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:
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 :

### 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 :

### 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 :
Ce code affiche :

### Manipulateur setfill(char)

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

### 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 :
Ce code affiche :

### 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

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

#### ios_base::oct

    Écrire/lire les entiers en base octale (base 8).

#### ios_base::dec

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

#### ios_base::hex

    Écrire/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

    Écrire les nombres réels avec une virgule fixe.

#### ios_base::scientific

    Écrire 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

    Écrire les données en majuscules.