Structures de données IFT-2000 Abder Alikacem Les entrées/sorties en C++ Édition Septembre 2009 Département d’informatique et de génie logiciel

Plan Les fonctions d’entrée/sortie Les manipulateurs Les sorties formatées Les fonction d’entrée/sortie avec les fichiers Strings et streams

Les entrées/sorties Les fonctionnalités d'entrées / sorties en C++ sont orientées objet. Elles sont gérées par le biais d’un ensembles de type (classes) spécialisés, les flots (streams). L’idée de base des flots est de séparer l’aspect logique des entrées-sorties (i.e. leur intégration dans des programmes) de leur aspect physique (i.e. leur réalisation par le biais de périphériques particuliers). Ainsi, un flot représente un flux de données entre le programme et un dispositif d’entrée-sorties externe (écran, imprimante, ...) ou un fichier. La librairie standard <iostream> permet de faire des entrées-sorties par flots. Notons que pour obtenir de meilleures performances, un tampon mémoire, par lequel les données transitent, est par défaut associé à chaque flot.

Les entrées/sorties ios iostream istream ostream La famille des iostream Une stream en C++ : séquence de caractères permettant de faire les opérations d'entrées/sorties. Une ostream gère les sorties inclut la définition de l'opérateur d’insertion <<. Une istream gère les entrées inclut la définition de l'opérateur d’extraction >>.

Les entrées/sorties La famille des iostream Une ostream peut être redirigée vers : l'écran (cout), la console d'erreur (cerr), le fichier d'historique (clog), un fichier (ofstream), un espace en mémoire (ostringstream, ostrstream). Une istream peut être redirigée vers : le clavier (cin), un fichier (ifstream), un espace en mémoire (istrstream).

Les entrées/sorties <iostream> est plus sûr du point de vue typage que <stdio.h> du C, est moins source d'erreurs, améliore les performances, est extensible, et enfin que certaines des classes qui le composent peuvent être sous-classées. Plus sûre du point de vue typage: avec <iostream.>, le type de l'objet sujet à une E/S est connu statiquement par le compilateur. <stdio.h> utilise lui les champs "%" pour connaître dynamiquement le type de l'objet. Moins sources d'erreurs: avec <iostream.>, il n'est pas nécessaire d'utiliser ces champs "%", qui sont redondants et qui doivent être consistants avec l'objet effectivement sujet à l'E/S. Enlever cette redondance élimine toute une catégorie d'erreurs possibles. Extensibles: les mécanismes C++ de <iostream.h> permetttent à l'utilisateur de définir de nouveaux types qui pourront être sujets à des E/S, et ce sans casser le code existant. Imaginez le chaos que ça créerait si chacun ajoutait ses propres champs, incompatibles, "%" à printf() et à scanf()!.

Les entrées/sorties Sous-classables: les mécanismes C++ de <iostream.h> sont construits sur des classes, comme par exemple ostream et istream. À la différence du FILE* de <stdio.h>, ce sont de vraies classes et elles sont de ce fait sous-classables. Cela signifie que vous pouvez avoir vos propres types utilisateur, qui ressemblent à des flots (streams) et qui agissent comme tels, mais qui font aussi toutes les choses étranges et merveilleuses que vous avez décidé. Vous accédez automatiquement à des tonnes de code d'E/S écrits par des utilisateurs que vous ne connaissez même pas, utilisateurs qui eux-mêmes n'ont rien besoin de connaître de votre classe de "flot étendu". Les principales conséquences dans l'utilisation des flots sont: vitesse d'exécution plus rapide vérification de type : pas d'affichage erroné on peut utiliser les flux avec les types utilisateurs

Les entrées/sorties Les flots de sorties (de type std::ostream) sont std::cout et std::cerr pour le standard et l’erreur respectivement. Le flot d’entrée (de type std::istream) est std::cin. Comme l’indique le préfixe std::, tous ces objets sont dans le namespace std. • cin : flot lié à l’entrée standard, qui par défaut est le clavier • cout : flot lié à la sortie standard, qui par défaut est la console • cerr : flot lié à la sortie d’erreur standard, qui par défaut est la console Les opérations de sorties sont réalisées à l’aide de l’opérateur d’insertion « << », tandis que celle d’entrées le sont à l’aide de l’opérateur d’extraction, « >> ».

cout << expression; Les entrées/sorties Par exemple, l'écriture à l'écran de la valeur d’une expression se traduit par le code suivant : cout << expression; cout << "Bonjour"; //Affiche Bonjour Cela sous entend la surcharge de l'opérateur << pour le type de donnée correspondant à expression. Ce travail a été réalisé pour la plupart des types de base du C++. Il vous appartiendra de le faire pour vos propres classes (surcharge des opérateurs << et >>).

Les entrées/sorties Le concept de flots d’octets C++ Description C iostream bibliothèque C++ des flots stdio.h istream flot d ‘entrée – ostream flot de sortie - << opération de sortie printf >> opération d ‘entrée scanf cin flot entrée standard stdin cout flot de sortie standard stdout cerr flot de sortie des erreurs stderr clog flot de sortie des erreurs - endl fin de ligne ” \n ‘

Les entrées/sorties Le concept de flots d’octets Les opérateurs << et >> sont génériques. On peut mélanger les types. short s = 1; int i = 2; long l = 3; float f= 4.5; double d = 6.7; cout<<"s= "<<s<<"i= "<<i…"d= "<<d<<endl; Il n ‘y a plus de chaîne de format à la « printf».

Les entrées/sorties Le concept de flots d’octets Les opérateurs << et >> sont génériques. Ils sont définis sur les types: bool, short, int, long float, double char, char* On doit les redéfinir soi-même pour les types que l ‘on crée si on veut les afficher.

Les entrées/sorties Le concept de flots d’octets On dispose de manipulateurs spéciaux sur les flots C++ C syntaxe fait quoi flush fflush cout << flush; vide le tampon endl \n + fflush cout << endl; fin de ligne hex - cout << hex; hexa oct - cout << oct; octal dec - cout << dec; décimal ws - cin >> ws; élimine blancs

Les entrées/sorties Exemples int n=2; double f=1.5; char c='z'; cout<<n; // afficher un entier sur la sortie standard cout<<f<<endl; // afficher un double et un changement de ligne cout<<"n = "<<n; // afficher: n = 2 cout<<c; // afficher un caractère cin >>c; // lire un caractère (saute les espaces) cin.get(c) // lire un caractère (ne saute pas les espaces) cin >>n>>f; // lire un entier puis un double cerr<<"Erreur"; // afficher un message sur l'erreur standard

Les entrées/sorties Syntaxe pour l’écriture sur la sortie standard (écran) cout << <expression1> << <expression2> << ... << <expressionn>; Les opérateurs << sont prévus pour être chaînés. Vous pouvez donc les cumuler sur la même ligne de code, par exemple: int i; int j; cout << i << " " << j << endl; La constante symbolique endl vous permet de changer de lignes indépendamment de l'architecture dans laquelle le programe évolue. Les chaînes de caractères doivent être indiquées entre guillemets anglais «"», tandis que les caractères simples sont eux indiqués entre apostrophes «’». Les valeurs affichées ne sont, pas délimitées par défaut (pas d’espaces séparateurs). Les délimiteurs sont donc à indiquer explicitement, par exemple par ‘ ‘ ou" ". Un retour de chariot ( '\n' )

Les entrées/sorties Syntaxe pour la lecture sur l’entrée standard (clavier) cin << <var1> << <var2> << ... << <varn>; #include <iostream> int main() { int i; double x; cout << "Valeurs pour i et x: " << flush; cin >> i >> x; cout << "=> " << i << ", " << x << endl; return 0; } Le manipulateur flush permet d’assurer l’affichage de la ligne courante, en l’absence de saut de ligne (il ordonne le vidage du tampon d’affichage). Remarque. cerr n’a pas de tampon mémoire: toutes les données introduites sont immédiatement acheminées vers la sortie d’erreur standard. Il n’est donc pas nécessaire, pour ce flot, de demander explicitement le vidage du tampon mémoire au moyen de flush.

Les entrées/sorties cin/cout définis dans <iostream> inclure l'entête cin/cout, les opérateurs << et >> et la classe string définis dans le namespace std. Dans un .cpp : ajouter au début du fichier using namespace std; Dans un .h : évitez le using, utilisez plutôt explicitement le nom du namespace avec :: using namespace :: cin; usinf namespace:: cout; using namespace :: endl;

Les entrées/sorties #include <iostream> #include <string> using namespace std; int main() { cout << "Entrez votre nom : " ; string nom; cin >> nom; cout << "Entrez votre poids (Kg): " ; double poids; cin >> poids; cout << "Bonjour : " << nom << endl; cout << "Votre poids est " << poids << "kilo" << endl; return 0; } Problème si des espaces. Utilise plutôt un buffer et méthodes de cin.

Les entrées/sorties Des méthodes des iostream La istream : En plus d'utiliser l'opérateur surchargé >> … méthodes intéressantes get() ignore() getline(). La ostream : En plus d'utiliser l'opérateur surchargée << … méthodes intéressantes : precision() width() fill() setf() et unsetf()

Les entrées/sorties std::istream& get() Quelques surcharges : int istream::get() Pour obtenir le code ASCII d'un caractère istream& istream::get(char& c) Pour obtenir un caractère istream& istream::get(char* strP, int dim, char delim = '\n') Pour obtenir une chaîne de caractères d'une dimension déterminée, ou jusqu'à un caractère de fin, ici par défaut à '\n' prend les espaces mais ne consomme pas le caractère de fin.

Les entrées/sorties std::istream& get() int istream:: get(), pour obtenir le code ASCII d'un caractère. cout << "Entrez un caractère "; int entier = cin.get(); cout << "Le code ASCII est : " << entier << endl; Résultat Entrez un caractère : A Le code ASCII est : 65

Les entrées/sorties std::istream& get() #include <iostream> using namespace std; int main() { char unChar; cout << "Entrez un caractere [. pour quitter]: "; cin.get(unChar); while (unChar != '.') if (cin) cout << "Le caractere est : " << unChar << endl << endl; } // --- On consomme la fin de ligne cin.get(); return 0; istream& istream::get(char& c), pour obtenir un caractère dans le paramètre c.

Les entrées/sorties std::istream& get() istream& istream::get(char* strP, int dim, char delim = '\n'), pour obtenir une chaîne de caractères d'une dimension déterminée ou jusqu'à un caractère de fin, ici par défaut à '\n'. Prend les espaces mais ne consomme pas le caractère de fin. Si dimension dépassée les caractères supplémentaires resteront dans la stream jusqu'au délimiteur. Il faut gérer cette possibilité : vider la stream de ses caractères.

Les entrées/sorties std::istream& get() #include <iostream> using namespace std; int main() { char buffer[11]; cout << "Entrez une chaine [. pour quitter]: "; cin.get(buffer, 10); while (strcmp(buffer, ".") != 0) if (cin) cout << "La chaine de caractères est : " << buffer << endl; } cin.get(); // On consomme la fin de ligne car non récupéré de la stream. return 0; std::istream& get()

Les entrées/sorties std::istream& get() Résultat: Entrez une chaîne [. pour quitter] : Jean-Luc La chaîne de caractères est : Jean-Luc Entrez une chaîne [. pour quitter] : Jean-Luc Boutin La chaîne de caractères est : Jean-Luc B //Prend seulement 10 caractères Entrez une chaîne [. pour quitter] : La chaîne de caractères est : utin //Le 'o' est consommé par cin.get() //et "utin" est immédiatement affiché.

La fonction symétrique de get() est put() Les entrées/sorties std::ostream& put() La fonction symétrique de get() est put() int main() { char c; while(cin.get(c)) cout.put(c); return 0; }

Les entrées/sorties std::istream& ignore() Pour enlever les caractères non désirés dans la stream : istream::ignore() Par défaut, ignore() sans paramètre est l'équivalent de get(). Permet de spécifier le nombre maximal de caractères à enlever ainsi que la condition de fin ou délimiteur, par défaut à '\n'. Choisir un nombre arbitrairement grand pour s'assurer de vider la stream avant de continuer.

Les entrées/sorties std::istream& ignore() #include <iostream> using namespace std; int main() { char buffer[11]; cout << "Entrez une chaine [. pour quitter]: "; cin.get(buffer, 10); while (strcmp(buffer, ".") != 0) if (cin) cout << "La chaine de caractères est : " << buffer << endl; } // --- On consomme tous les caractères laissés dans // --- la stream jusqu'à la fin de ligne. cin.ignore(100, '\n'); return 0; std::istream& ignore()

Les entrées/sorties std::istream& ignore() Résultat: Entrez une chaîne [. pour quitter] : Jean-Luc La chaîne de caractères est : Jean-Luc Entrez une chaîne [. pour quitter] : Jean-Luc Boutin La chaîne de caractères est : Jean-Luc B Entrez une chaîne [. pour quitter] : // Les autres caractères ont été // consommés par la méthode // istream::ignore(100).

Les entrées/sorties std::istream& getline() permet de lire une ligne entière ou la dimension du buffer. istream& getline(char* strP, int dim, char c = '\n'); Permet donc de lire une ligne sans avoir à s'occuper de la fin de ligne. La fin de ligne est consommée par la méthode. Il faut disposer de suffisamment de mémoire pour lire la ligne : 256, 512 ou 1024 caractères ou plus selon les besoins.

Les entrées/sorties std::istream& getline() La fonction getline() permet donc de lire une ligne complète, séparateurs compris. const int MAX = 10; int main() { char t[MAX]; while(cin.getline(t, MAX, ‘\n‘)) cout << t << endl; return 0; }

Les entrées/sorties std::istream& getline() #include <iostream> using namespace std; int main() { char buffer[256]; cout << "Entrez le point [.] pour quitter : "; cin.getline(buffer, 255); while (cin && strcmp(buffer, ".") != 0) if (cin) cout << "La chaine de caractères est : " << buffer << endl; } return 0;

Les entrées/sorties std::istream& getline() Résultat: Entrez une chaîne [. pour quitter] : Voici une longue phrase sur une ligne... La chaîne de caractère est : Voici une autre longue phrase sur une ligne ...

Les entrées/sorties ostream::width() Permet de spécifier la largeur du champ à afficher. Par défaut, l'alignement est à droite. L'application de la méthode width() ne tient que pour le prochain champ à afficher. Si on veut que cela s'applique à tous les prochains champs à afficher : appeler la méthode width() avant d'afficher chaque champ. Si la largeur du champ n'est pas suffisante pour afficher le champ, le C++ ne tient pas compte de la largeur la donnée est plus importante que sa présentation...

Les entrées/sorties ostream:: width() Exemples // --- Appel une seule fois avant d'afficher les champs cout.width(10); for (int i=0; i<3; i++) { cout << 123 << endl; } cout << endl; // --- Appel à chaque affichage d'un champ for (int j=0; j<3; j++) cout << 321 << endl; Résultat 123 321

Les entrées/sorties ostream:: width() Exemples Résultat cout << "--------------------" << endl; cout.width(5); cout << 123; cout.width(7); cout << 543; cout.width(3); cout << 4; cout << 9876 << endl; //Il y aura décalage, à cause de la largeur du 1er champ. cout << 123456; Exemples Résultat [---][-----][-][---] -------------------- 123 543 4 9876 123456 543 4 9876

Les entrées/sorties ostream::precision() Permet de contrôler le nombre de chiffres significatifs visibles à l'affichage. Par défaut : 6 chiffres significatifs. On peut spécifier le nombre de chiffres significatifs désirés. Un appel de precision() est valide jusqu'à ce que la précision soit changée.

Les entrées/sorties ostream::precision() int i; double valeurs[5]; for (i=1; i<5; i++) { valeurs[i] = valeurs[i-1] * 0.10; } cout << "Affichage avec la précision par défaut" << endl; for (i=0; i<5; i++) cout.width(10); cout << valeurs[i] << endl; cout << "Affichage avec précision(3)" << endl; cout.precision(3); ostream::precision() Résultat Affichage avec la précision par défaut 54.354 5.4354 0.54354 0.054354 0.0054354 Affichage avec précision(3) 54.4 5.44 0.544 0.0544 0.00544

Les entrées/sorties ostream::fill() Permet de spécifier le caractère de remplissage qui peut être ajouté dans les champs affichés. Par défaut : un espace. Pour changer temporairement le caractère de remplissage, fill() : retourne le caractère courant de remplissage prend en paramètre celui en remplacement : char ostream::fill(char fill) Si on conserve l'ancien caractère, on peut restaurer l'état de la stream après usage.

Les entrées/sorties ostream::fill() int i; double valeurs[5]; for (i=1; i<5; i++) { valeurs[i] = valeurs[i-1] * 0.10; } cout << "Remplissage de l'espace libre avec des *" << endl; char f = cout.fill('*'); for (i=0; i<5; i++) cout.width(10); cout << valeurs[i] << endl; cout << "Restauration du remplissage précédent" << endl; cout.fill(f); ostream::fill() Résultat: Remplissage de l'espace libre avec des * ******54.4 ******5.44 *****0.544 ****0.0544 ***0.00544 Restauration du remplissage precedent 54.4 5.44 0.544 0.0544 0.00544

Les entrées/sorties ostream::setf() et ostream::unsetf() Objet de type ostream : maintient des états dans un entier où chaque bit représente quelque chose. On peut activer un état avec setf() ou le désactiver avec unsetf(). plusieurs états (format flags) Pouvant être contrôlés par ces deux méthodes. Exemple intéressant : comment conserver plusieurs renseignements dans un seul entier. Chaque bit de l'entier correspond à un état. En faisant un OU binaire sur l'entier, on arrive à activer ou désactiver le ou les états désirés.

Les entrées/sorties Quelques états intéressants ios::left : alignement sur la gauche avec remplissage sur la droite. ios::right : alignement par défaut avec remplissage sur la gauche. ios::fixed : affichage des réels en format fixe. ios::scientific affichage des réels en format scientifique. ios::showpos affichage du signe positif Il existe d'autres états!

Les entrées/sorties Exemples // Alignement à gauche, format scientifique, signe positif, // précision 8 chiffres après le point, champs de largeur 20 caractères. cout.setf(ios::left | ios::scientific | ios::showpos); cout.precision(8); cout.width(20); cout << 3457.891234 << endl; cout << -3457.891234 << endl; // --- Enlève le signe positif // --- Alignement à droite, format fixe, précision 8 chiffres total, // --- champs de largeur 20 caractères. cout.unsetf(ios::showpos); cout.setf(ios::right | ios::fixed); Résultat +3.45789123e+003 -3.45789123e+003 3457.8912 -3457.8912

Les entrées/sorties Autres fonctions de flots #include <iostream> int const MAX = 10; // eof+bad+good+fail+clear test int main() { char line[MAX]; for (;;){ cin.getline(line, MAX, '\n'); if (cin.fail()) cout << " fail "; if (cin.bad()) cout << " bad "; if (cin.good()) cout << " good "; if (cin.eof()) break; if (!cin.good()) cin.clear(); cout << line << endl; } cout << "eof" << endl; return 0; eof() fin de fichier fail() erreur bad() problème grave good() pas de problème clear() annule les problèmes

Les manipulateurs Un certain nombre de paramètres pour le format des sorties peuvent être explicitement spécifiés. Ces paramètres sont de deux formes: ➱ Soit des manipulateurs, appliqués à l’opérateur « << » ➱ Soit des options de configurations, appliqués directement au stream de sortie Manipulateurs Pour utiliser les manipulateurs, il faut au préalable importer les définitions du fichier iomanip au moyen de la directive d’inclusion: #include <iomanip> On utilise les manipulateurs très simplement, en les insérant directement dans le flot, à l’endroit désiré, exactement comme avec les données: cout << «donnée» << «manipulateur» << «donnée» << ...

Les sorties formatées Longueur de la représentation: setw(«taille») La donnée qui suit ce manipulateur est affiché sur (au moins) taille caractères, avec (par défaut) un cadrage à droite, fort pratique lors de la représentation en colonnes des nombres. #include <iomanip> cout << setw(10) << "un:" << setw(5) << 1 << endl; cout << setw(10) << "cent deux:" << setw(5) << 102 << endl; cout << setw(10) << "moins 18:" << setw(5) << -18 << endl; un: 1 cent deux: 102 moins 18: -18

Les sorties formatées Caractère de remplissage: setfill(«char») Il définit le caractère utilisé pour pour réaliser le remplissage lors d’un alignement (par défaut le caractère espace): #include <iomanip> cout << setw(10) << "un:" << setfill(’.’) << setw(5)<< 1; cout << endl << setw(10) << "cent deux:" << setfill(’.’) << setw(5) << 102; cout << endl << setw(10) << "moins 18:" << setfill(’.’) << setw(5) << -18 un:…1 cent deux:..102 moins 18:..-18

Les sorties formatées Précision en virgule flottante: setprecision(int) Il définit le nombre de chiffres significatifs sur lequel se fera l’affichage des nombre en virgules flottantes (par défaut 6, partie entière + décimale): #include <iomanip> for (int i(2); i<6; ++i) { cout << setprecision(i) << i << ’ ’ << 314.1592654 << endl; } 2 3.1e+002 3 314 4 314.2 5 314.16

Les entrées/sorties Comme avec les printf du C, il est donc possible de spécifier des formats d'affichage à la manière des fameux "%6.2f" dans le langage C. L'exemple suivant créé l'équivalent d'un printf("6.2f",r); #include <iostream> #include <iomanip> using namespace std; int main(int, char **) { double r=36.145278; int i=5; cout << setw(6) << setprecision(4) << r << endl; cout << i << " " << i++ << endl; cout << i << endl; return 0; } Les appels sont réalisés de la droite vers la gauche. Les expressions que vous affichez sont présentées dans l'ordre que vous avez demandé mais elles ont été évaluées dans l'ordre inverse. De plus, setprecision(4) sera active pour les éventuelles impressions de réels. 36.14 6 5 6

Entrée/sortie avec des fichiers Fichier : séquence d’octets terminée par une « marque de fin de fichier » (EOF). En C++ : vus comme des flux d’octets ou de caractères. ofstream : Pour l’écriture dans un fichier. ifstream : Pour la lecture à partir d’un fichier. Deux types de lecture/écriture : Mode texte : Peut être lu comme un document texte, caractère par caractère, mot par mot, ligne par ligne, etc. Mode binaire : décoder les informations, octet par octet. Se trouve dans l’entête <fstream>

Entrée/sortie avec des fichiers texte Le lien entre les fichiers du système d’exploitation et le programme se fait en C++ par le biais des streams. Un flot de données de type stream – orienté ou bidirectionnel – peut être associé à un fichier, et s’utilise de la même manière que les flots vers ou en provenance de la console (cin, cout, cerr).

Entrée/sortie avec des fichiers texte Pour pouvoir utiliser les streams liés aux fichiers, il faut importer, en début de programme, les prototypes et définitions contenus dans la librairie, au moyen de la directive d’inclusion: #include <fstream> Deux types (classes) sont alors disponibles: ➱ ifstream (input file stream) stream d’entrée associé à un fichier ouvert en mode lecture (similaire à cin) ➱ ofstream (output file stream) stream de sortie, associé à un fichier ouvert en mode écriture (similaire à cout).

Entrée/sortie avec des fichiers texte Le mécanisme général pour la mise en oeuvre d’entrée-sorties via les fichiers est: (1) Création d’un stream (d’entrée ou de sortie), par la déclaration d’une variable de type ifstream ou ofstream. Exemple ifstream entree; ofstream sortie; (2) Association de la variable avec un fichier physique, par l’appel de la fonction-méthode open, en respectant la syntaxe d’appel définie dans le paragraphe concernant les vecteurs. Exemple entree.open("input.txt"); qui associe le stream entree avec le fichier nommé «input.txt» (présent dans le répertoire courant). (3) Utilisation du stream: par des appels à des fonctions-méthodes, et l’utilisation des opérateurs d’insertion («>>») et d’extraction («<<») de données. (4) Fermeture du stream, au moyen de la fonction-méthode close Exemple entree.close();

Entrée/sortie avec des fichiers texte Les opérations (1) et (2), à savoir la déclaration de la variable et son association avec un fichier, peuvent se réaliser en une seule étape. L’initialisation lors de la déclaration se fait alors en spécifiant entre parenthèses le nom du fichier à lier au stream: Exemple ifstream entree("input.txt"); On peut considérer que l’initialisation fait directement appel à la fonction open. La fonction open admet comme argument une chaîne de caractères de type "..." (en fait un char[]): il n’est donc pas possible d’utiliser directement une chaîne de type string (en effet, s’il y a conversion implicite des chaînes de la forme "..." vers les strings (promotion), l’inverse n’est pas vrai.) . Il faut dans ce cas demander la conversion en type char[] du string, en faisant appel à la fonction-méthode c_str: Exemple string str("output.txt"); ifstream entree2; ofstream sortie(str.c_str()); entree2.open(str.c_str());

Entrée/sortie avec des fichiers texte Exemple 2 ifstream de("fichier1"); // définition de la variable: de if (!de) { cerr<<"Impossible d'ouvrir fichier1 en lecture\n"; exit(1); } ofstream vers("fichier2"); // définition de la variable: vers if (!vers) cerr<<"Impossible d'ouvrir fichier2 en écriture\n"; char c; while(de.get(c)) //copie de fichier1 vers fichier2 vers<<c;; get(c) retourne faux si on est à la fin du fichier, sinon elle retourne vrai.

Entrée/sortie avec des fichiers texte L’utilisation dans le programme des variables de type fstream pour effectuer des entrées-sorties se fait de la même manière que pour les streams cin et cout, c’est-à-dire à l’aide des opérateurs d’insertion «>>» et d’extraction «<<». ifstream entree("input.txt"); ofstream sortie("output.txt"); string mot; int n; entree >> mot >> n; sortie << "Le mot lu est: ’" << mot << "’ et le " << "nombre est: ’" << n << "’." << endl; Exemple Remarque. Une fonction utile pour tester si le lecture d’un fichier est Terminée est la fonction/méthode eof. if (entree.eof()) { cout << "Fin du fichier" << endl; }

Entrée/sortie avec des fichiers texte Le programme ci-dessous saisit une phrase via l’entrée standard (clavier), et l’écrit (un mot par ligne) dans un fichier texte nommé «phrase.txt». #include <iostream> #include <fstream> #include <string> int main() { string motSaisit; string nomFichier("phrase.txt"); ofstream sortie(nomFichier.c_str()); cout << "Entrez une phrase terminée par « .»" << endl; do cin >> motSaisit; sortie << endl << motSaisit; } while (motSaisit != "."); sortie.close(); return 0; }

Entrée/sortie avec des fichiers texte Le programme ci-dessous relit le fichier créé par le programme précédant, et affiche la phrase à l’écran, et remettant les mots sur une même ligne. #include <iostream> #include <fstream> #include <string> int main() { string motSaisit; ifstream entree("phrase.txt"); while (!entree.eof()) entree >> motSaisit; cout << motSaisit << ’ ’; } cout << endl; entree.close(); return 0;

Entrée/sortie avec des fichiers texte De même qu’il est conseillé de contrôler la conformité des valeurs entrées par un utilisateur, il est bon de vérifier que l’association d’un stream avec un fichier s’est correctement réalisée (i.e. que le fichier existe, est lisible, etc). Pour cela, on peut «évaluer le stream», après l’appel à la fonction open.Si tout c’est bien passé, le résultat de cette évaluation sera true,et il sera false en cas de problème. Exemple entree.open("fichier-inexistant"); if (!entree) cout << "Oops, le fichier n’est pas lisible!" << endl; else << cout << "Ok, le fichier existe et est lisible!" << endl; Plus précisément, un certain nombre de prédicats, déjà rencontrés, sont associés aux streams, et permettent d’en connaître l’état: bool good() le stream est dans un état correct, la prochaine opération (lecture/écriture) sera un succès. bool eof() la fin du stream à été atteinte. bool fail() la prochaine opération (lecture/écriture) échouera. Elle sert lors de l’«évaluation» d’un stream. bool bad() le stream est corrompu: des données ont été perdues (et la prochaine opération échouera).

Entrée/sortie avec des fichiers texte Retour sur les fonctions open() et close() Ouverture d’un fichier avec un mode explicite Modes C++ Signification ios::in read ios::write write ios::app append ios::binary binaire En C flot.open("toto1", ios::out); f= fopen("toto1", "w"); flot.open("toto2", ios::in); f= fopen("toto2", "r");

Entrée/sortie avec des fichiers texte Les fonctions open() et close() Un fichier est automatiquement ouvert à la création d ‘une variable si on utilise la syntaxe suivante: ofstream ofs ("toto.out", ios::out); ifstream ifs ("toto.in", ios::in); Déclarer un objet de type ofstream (fichier en sortie) ou ifstream (fichier en entrée): 1er argument : le chemin et le nom du fichier. 2e argument : le type d’ouverture ios::out : Efface tout le contenu, si le fichier existait déjà. ios::app : Écrit après ce qu’il y a déjà dans le fichier. Si le fichier n’existe pas, il est créé dans les deux cas. Le fichier doit exister dans le cas d’un fichier en entrée

Entrée/sortie avec des fichiers texte Les fonctions open() et close() flot.fclose(); C++ est « dynamique»: lorsqu‘une variable de flot n ‘existe plus, le fichier éventuellement attaché au flot est automatiquement fermé.

Entrée/sortie avec des fichiers texte Exemple 1 //Ouverture d'un fichier en écriture ofstream ofs ("Moto.dat",ios::out); if (!ofs) { cerr << "Ouverture impossible" <<endl; return 1; } ofs << 2 << endl; // nombre de motos ofs << "Honda Shadow" << endl; ofs << 1986 <<endl; ofs << "Honda Valkyrie Rune" << endl; ofs << 2004 << endl; // Pour forcer la fermeture ofs.close(); Si le fichier ne peut être ouvert ( mauvais chemin ou déjà ouvert ), l’opérateur ! Renvoie faux. Pourra être relue comme une ligne entière 2 Honda Shadow 1986 Honda Valkyrie Rune 2004

Entrée/sortie avec des fichiers texte Exemple 2 {//Ouverture d'un fichier en écriture ifstream ifs("Moto.dat",ios::in); if(!ifs) { cerr << "Ouverture impossible" <<endl; return 1; } char ligne[256]; int nbMotos; ifs >> nbMotos; ifs.ignore(100, '\n'); for (int i=0; i<nbMotos; i++) ifs.getline(ligne,255); cout << " Modele : " << ligne << endl; ifs >> annee; cout << " Annee : " << annee << endl << endl; } // destructeur de ifs appelé, qui ferme le fichier Modèle : Honda Shadow Annee : 1986 Modèle : Honda Valkyrie Rune Annee :2004

Strings et streams Il peut parfois être utile, en vue d’effectuer des traitements particuliers, de disposer d’une représentation sous forme de chaîne de caractères des différentes variables d’un programme. Une telle convertion de représentation est automatiquement réalisée lorsque l’on insère ces éléments dans un stream de sortie, tel que cout. Mais peut-on récupérer ce qui est transmis dans le flot ? À défaut de récupérer ce qui est effectivement transmis, on peut du moins en obtenir l’équivalent sous forme de string, en utilisant des strings hybrides, associés à des streams. Ces entités hybrides sont désignées « stringstream». Pour pouvoir utiliser les stringstream dans un programme, il faut importer les prototypes et définitions contenus dans la librairie, au moyen de la directive d’inclusion: #include <sstream>

Stringstream de sortie Pour obtenir la représentation alphanumérique d’une variable, il faut utiliser un stringstream de sortie, dans lequel on insérera les données désirées (de la même manière qu’avec cout) avant d’en extraire l’équivalent sous forme de chaîne de caractère. Le type (la classe) matérialisant de tels éléments est désigné: ostringstream, et l’extraction de la représentation chaîne s’obtient au moyen de la méthode: string str(). #include <sstream> ... string composeMessage(const int errno, const string& description) { ostringstream ost; ost << "Erreur (n°" << errno << "): " << description; return ost.str(); } Exemple

Stringstream d’entrée Il est également possible de réaliser des entrées depuis un string (au lieu du clavier, avec cin): il suffit d’initialiser un stringstream d’entrée avec la chaîne désirée, et d’utiliser l’opérateur d’extraction sur le stream ainsi obtenu. Le type (la classe) utilisé est: istringstream. Exemple #include <sstream> ... // Extrait les mots d’un string, et les affiches à // raison de un par ligne void wordByWord(const string& str){ istringstream ist(str); string s; while (ist >> s) {cout << s << endl;} } // en utilisant la fonction précédante: wordByWord("Erreur (no5): Fichier non trouvé."); Erreur (n˚5): Fichier non trouvé.

Hiérarchie des classes représentant les flots