Formation C++ - Partie 2

Transcription

1 Formation C++ - Partie Yann Hamdaoui <yago@via.ecp.fr> VIA mai 0

2 Les objets c'est la classe! Construire, détruire Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs 4 Catch me if you can 5 Les template Chaînes de caractères Les entrées-sorties

3 er cours : bases du langage, syntaxe, programmation impérative cet amphi : des concepts, comment structurer votre code. Vous allez apprendre la programmation orientée objet (ou POO), qui diérencie le C du C++

4 Retour en classe Les objets c'est la classe! Construire, détruire Manipulation d'entités : fenêtres, chiers, utilisateurs, connexions, évènements... On les regroupe par catégories : ce sont les classes. Elles dénissent une structure logique, c'est une description

5 Retour en classe Les objets c'est la classe! Construire, détruire Une classe est composée de ses attributs, qui constituent ses données, et des diérents traitements qui s'y rapportent, les méthodes Les objets, ou instances d'une classe, correspondent aux entités concrètes que l'on manipule : par exemple, il y a une seule classe File, mais on peut en manipuler plusieurs objets File dans un programme

6 Retour en classe Les objets c'est la classe! Construire, détruire En pratique : On rééchit à la structure de notre programme On dénit les classes correspondantes = dénir des nouveaux type On peut construire de nouvelles variables de type File, User, etc..., accèder (oupas) à leurs attributs et utiliser leurs méthodes (fonctions)

7 Exemple Les objets c'est la classe! Construire, détruire class pile_entier { public : int taille ; int [] donnees ; int index_courant ; int depiler () { return donnees [-- index_courant ]; } void empiler ( int donnee ) { donnees [ index_courant ++] = donnee ; } };

8 Accès Les objets c'est la classe! Construire, détruire Syntaxe Pour accèder à un attribut d'un objet, on utilise objet.nomattribut que l'on manipule comme une variable quelconque De même, pour appeler une fonction, on écrit objet.nommethode(arg,arg,... )

9 Exemple Les objets c'est la classe! Construire, détruire pile_entier pile ; pile. taille = 00; pile. donnees = new int [ pile. taille ]; pile. index_courant = 0; pile. empiler (5); pile. empiler (); int j = pile. depiler () + pile. depiler (); // j =

10 Que vois-je? Les objets c'est la classe! Construire, détruire Dans une fonction, un paramètre du même nom qu'un attribut masque ce dernier dans le code d'une classe, le pointeur this réfère à l'objet sur lequel la méthode est appelée utilisation de this pour accèder aux attributs et méthodes

11 Que vois-je? Les objets c'est la classe! Construire, détruire class truc { public : int zorglub ; void oiser ( int zorglub ) { zorglub = 5; } }; truc variable ; variable. zorglub = ; variable. oiser (0); // variable. zorglub vaut toujours

12 Que vois-je? Les objets c'est la classe! Construire, détruire class truc { public : int zorglub ; void oiser ( int zorglub ) { this - > zorglub = 5; } }; truc variable ; variable. zorglub = ; variable. oiser (0); // variable. zorglub vaut bien 5

13 Être statique? Les objets c'est la classe! Construire, détruire Dénition En C++, un attribut ou une méthode statique est un membre qui est commun (c'est à dire partagé) à toutes les instances d'une classe Exemples : l'attribut CARACTERE_SEPARATEUR pour la classe le l'attribut TAILLE_MAX ou NOMBRE_PILES pour la classe pile les fonctions générales ou utilitaires, les fonctions d'initialisation ou de conguration globale

14 Être statique? Les objets c'est la classe! Construire, détruire Syntaxe class une_classe { //... static type variable_statique ; 4 static type fonction_statique ( type arg, type arg, 5...) 6 { 7 instructions ; 8 } 9 }; 0 Utilisation : une_classe :: variable_statique = valeur ; une_classe :: fonction_statique ( arg, arg,...);

15 Constructeur Les objets c'est la classe! Construire, détruire Dénition Un constructeur est une méthode spéciale qui est appelée lors de la création d'un objet normalement ou via l'opérateur new. Il fonctionne comme une méthode, n'a pas de type, mais peut prendre des paramètres

16 Constructeur Les objets c'est la classe! Construire, détruire Syntaxe class nom_classe { type variable ; //... nom_classe ( type arg, type arg,...) { instructions ; } // methodes... }

17 Constructeur Les objets c'est la classe! Construire, détruire On n'est pas obligé d'en préciser : par défaut, une classe a un constructeur vide Si l'on en précise, on est obligé d'utiliser ceux-ci. Si on muni une clase d'un constructeur prenant deux paramètres, le constructeur par défaut n'existe plus et on est obligé de préciser ces paramètres lorsqu'on en créer une instance Comme les méthodes normales, il peut être surchargé

18 Constructeur Les objets c'est la classe! Construire, détruire Parfois, les membres de la classe sont eux-même des objets et doivent être initialisés par un constructeur. On utilise alors la syntaxe suivante : class truc { public : pile_entier pile ; int variable ; truc () : pile (5), variable () { } };

19 Destructeur Les objets c'est la classe! Construire, détruire Denition De même, il existe un destructeur, appelé lorsque la variable est détruite (via delete, ou lorsqu'on sort du bloc où elle a été crée). Il suit les même règles que le constructeur, mais prend un devant son nom.

20 Exemple Les objets c'est la classe! Construire, détruire class pile_entier { public : int taille, index_courant ; int donnees []; const static int TAILLE_STANDARD ; pile_entier () { taille = pile_entier :: TAILLE_STANDARD ; donnees = new int [ taille ]; index_courant = 0; } pile_entier ( int taille ) { this -> taille = taille ; donnees = new int [ this -> taille ]; index_courant = 0; } ~ pile_entier () { delete donnees ; }

21 Exemple Les objets c'est la classe! Construire, détruire pile_entier pile_taille_standard ; pile_entier petite_pile (0); pile_taille_standard. empiler (5); // ok, tout est initialise dans le constructeur!... 4

22 Constructeur de copie Les objets c'est la classe! Construire, détruire Il existe un constructeur particulier, appelé constructeur de copie. Il doit eectuer une copie d'un objet du même type. il sert à créer une copie explicitement il est aussi utilisé implicitement par le compilateur comme le constructeur sans arguments, toute les classe en ont un par défaut

23 Constructeur de copie Les objets c'est la classe! Construire, détruire Syntaxe classe une_classe { //... une_classe ( const une_classe & source ) { // operations de copie } }; 4 5 6

24 Constructeur de copie Les objets c'est la classe! Construire, détruire Exemple class pile_entier { public : int taille ; //.. pile_entier ( const pile_entier & source ) { donnees = new int [ source. taille ]; taille = source. taille ; index_courant = source. index_courant ; memcpy ( donnees, source. donnees, taille ); } };

25 Constructeur de copie Les objets c'est la classe! Construire, détruire Utilisation pile_entier pile (5); pile. empiler (0); pile_entier pile ( pile ); cout << pile. depiler () << endl ; // affiche bien 0 4 void afficher_pile ( pile une_pile ) {... }

26 Un peu de généalogie... Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Héritage En C++, et dans la POO en général, les classes sont organisées hiérarchiquement. Une classe (dite classe lle, ou sous-classe) peut hériter d'une autre (sa classe mere, ou super-classe). Elle hérite alors des variables et des méthodes de sa classe mère, comme si elle les avait déclaré elle-même.

27 Exemple Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs class pile_entier_safe : public pile_entier { public : pile_entier_safe () : pile_entier () { } 4 pile_entier_safe ( int taille ) : pile_entier ( taille ) { } 5 6 void empiler_bis ( int donnee ) { 7 if ( index_courant >= taille ) 8 cout << " Erreur : t a i l l e maximum a t t e i n t e! " << endl 9 ; else 0 empiler ( donnee ); } };

28 Exemple Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs pile_entier_safe pile (5); pile. empiler_bis (); pile. empiler (4); // non secure!

29 Exemple Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs class pile_entier_safe : public pile_entier { pile_entier_safe () : pile_entier () { } pile_entier_safe ( int taille ) : pile_entier ( taille ) { } 4 5 void empiler ( int donnee ) { 6 if ( index_courant >= taille ) 7 cout << " Erreur : t a i l l e maximum a t t e i n t e! " << endl 8 ; else 9 pile :: empiler ( donnee ); 0 } };

30 Exemple Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs pile_entier_safe pile (5); pile. empiler (4); // secure!

31 Ma famille d'abord Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Règles d'héritage Une classe A peut hériter de plusieurs classes mères. Si A hérite de B : A est du type B, mais pas l'inverse A peut redénir des fonctions de B, elles cachent alors celles de B. On accède à celle de B depuis A via l'accesseur ::.

32 Exemple Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs class classea { public : int variable ; classea () { cout << " c l a s s e A ( ) " << endl ; } void une_fonction () { cout << " c l a s s e A : : une_fonction ( ) " << endl ; } ~ classea () { cout << "~ c l a s s e A ( ) " << endl ; } }; class classeb : class classea { public : classeb () { cout << " c l a s s e B ( ) " << endl ; } void une_fonction () { cout << " ClasseB : : une_fonction ( ) " << endl ; } ~ classeb () { cout << "~ c l a s s e B ( ) " << endl ; } };

33 Exemple Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs { } classea * ptra = new classeb (); // affiche classea () puis classeb () classeb * ptrb = new classeb (); // pareil ptra - > une_fonction (); // une_fonction :: classea ()! ptrb - > une_fonction (); // une_fonction :: classeb () delete ptrb ; // ~ classeb () puis ~ classea () delete ptra ; // ~ classea ()!

34 Méthodes virtuelles Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Mot-clé virtual Pour éviter le comportement précédent, on utilise le mot-clé virtual. Il permet de rechercher d'abord les fonctions dans les classes lles, en remontant l'arbre généalogique. dans l'exemple précédent, aurait :

35 Méthodes virtuelles Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs class classea { public : virtual void une_fonction () {... }... }; }; // ailleurs classea * ptra = new classeb ; ptra - > une_fonction (); // classeb :: une_fonction ()!

36 Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Abstraction, Polymorphisme, Interfaces... Parfois, on veut décrire une fonctionnalité sans forcément vouloir la lier à une implémentation particulière. Les méthodes abstraites (ou virtuelles pures) le permettent. Dénitions Une méthode abstraite est une méthode qui n'a pas de corps (le code entre accolades) Une classe qui a au moins une méthode abstraite est dite abstraite elle-même Une classe qui hérite d'une classe abstraite et qui conserve au moins une méthode abstraite (sans la redénir avec un corps) est abstraite

37 Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Abstraction, Polymorphisme, Interfaces... Syntaxe class nom_classe { public : // du code 4 virtual }; type nomfonction ( type param, type param,...) =0;5 6

38 Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Abstraction, Polymorphisme, Interfaces... class composant_graphique { public : int width, height ; int x, y; 4 5 void cacher () {... } 6 void changer_couleur ( int red, int green, int blue ) {... 7} virtual void tracer ( screen ecran ) =0; 8 //... }; 9 class bouton : public composant_graphique { 0 public : void tracer ( screen ecran ) { ecran. tracer_ligne (x,y, x+ width, y ); //... 4 } 5 }; 6

39 Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Abstraction, Polymorphisme, Interfaces... Règles de programmation Une classe abstraite ne peut pas être instanciée (mais elle peut avoir un constructeur et un destructeur) On ne manipule donc en réalité que des instances de ses classes lles Mais une variable peut être du type d'une classe abstraite

40 Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Abstraction, Polymorphisme, Interfaces... Exemple composant_graphique composant ; // Non! composant_graphique * composant = new bouton (); // ok

41 Prototypes Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Comme pour les fonctions, on déclare en générale des prototypes de classe, et on les implémente après, ou autre part. Structure typique d'un programme C++ : prototype de classe : chier bidule.h (ou bidule.hpp) implémentation : soit dans le même chier, soit dans un chier bidule.cpp autres sources qui utilisent la classe : #include bidule.h hors de la classe, on utilise l'accesseur ::

42 Prototypes Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs chier pile_entier.h : class pile_entier { public : int taille ; int donnees []; int index_courant ; pile_entier (); pile_entier ( int taille ); // ou pile_entier ( int ) void empiler ( int donnee ); int depiler (); virtual ~ pile_entier (); };

43 Prototypes Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs pile_entier :: pile_entier () {... } void pile_entier :: empiler ( int donnee ) {... } int pile_entier :: depiler () {... } 4

44 Prototypes Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Certains mots-clés sont à remettre lors de l'implémentation (static, const, throw, etc...). Quelques-un, dont virtual, ne sont à mettre que dans la dénition de la classe.

45 Accès publique, accès privé Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Mots-clés d'accès En C++, certains mots-clés permettent de restreindre l'accès de membres ou de fonctions depuis l'extérieur de la classe : public : le membre ou la méthode est accessible librement depuis l'extérieur de la classe protected : le membre ou la méthode est accessible uniquement au sein de la classe et de ses classes lles private : le membre ou la méthode est accessible uniquement au sein de la classe

46 Accès publique, accès privé Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs On peut utiliser ces restricteurs pour de nombreuses raisons : variables ou fonctions utilitaires limiter les valeurs que l'on donne à une variable (ex : taille dans pile) interdire certaines opérations (ex : opérateur de copie)

47 Accès publique, accès privé Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Syntaxe class une_classe { acces : declarations ; acces : declarations ;... }; Remarque : l'enchaînement des accès est libre : on peut très bien alterner les accès, mettre le même plusieurs fois, etc...

48 Accès publique, accès privé Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Exemple : class pile_entier { protected : int taille ; int donnees []; public : pile_entier (); void empiler ( int entier ); ~ pile_entier (); protected : int index_courant ; private : pile_entier ( const pile_entier & source ); };

49 Héritage et accès Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs On a toujours mis le mot-clé public pour l'héritage : class pile_entier_safe : public pile_entier Ceci signie que tous les attributs et méthodes de pile_entier gardent leur "accès". Si par contre, on avait mis class pile_entier_safe : protected pile_entier alors, si pile_entier_safe ne redénit pas empiler() par exemple, on ne peut pas appeler empiler() sur un objet de type pile_entier_safe, sauf à l'intérieur de la classe et dans ses classes lles.

50 Héritage et accès Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs le mot-clé d'accès devant la classe mère ne peut que réduire l'accès des membres. Exemple : class mere { public : void fonction_publique (); private : void fonction_privee (); protected : void fonction_protegee (); }; class fille : protected mere { public : void test () { fonction_privee (); // Non! } public : void fonction_protegee (); };

51 Héritage et accès Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs fille une_fille ; une_fille. fonction_publique (); une_fille. fonction_protegee (); // non // oui

52 Surcharge d'opérateur Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Pour faciliter la programmation, on peut, en C++, redénir les opérateurs pour qu'ils fonctionnent sur des objets (+,-,++,[],(), etc...) Syntaxe Au sein d'une classe : on le déclare comme une fonction, de nom operatorx(args), où : X est l'opérateur args dépend de l'opérateur. Attention à ses propriétés dans le langage! le type de retour est libre

53 Surcharge d'opérateur Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Exemple class matrice { int n, m; int ** tableau ; //... matrice operator +( const matrice & autre ) { matrice temp (* this ); additioner ( temp, autre ); return temp ; } matrice operator +( const int & constante ) { // on ajoute constante a tous les coefs de tableau return * this ; } int & operator ()( int i, int j) { return tableau [i ][ j ]; } };

54 Surcharge d'opérateur Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs matrice m (0,0); m (0,0) = 5; cout << ( m + )(0,0) << endl ; // affiche 8

55 Surcharge d'opérateur Héritage L'art abstrait Modularité, vie privée et vie publique Surcharge d'opérateurs Remarque : on peut aussi dénir des opérateurs hors d'une classe, comme pour les stream. Par exemple : ostream & operator < <( ostream & stream, const pile_entier & pile_entier ) { pile_entier copie ( pile ); for ( i = 0; i < pile_entier. taille ; i ++) stream << pile_entier. depiler (); return stream ; }

56 Un peu de sémantique Catch me if you can Dans beaucoup de langages OO, les erreurs sont gérées via les exceptions. sont des classes particulières (on peut aussi utiliser les types de base) qui sont utilisées pour transmettre les erreurs entre deux parties d'un programme.

57 Ca mord? Catch me if you can On utilise les mots-clé try/catch pour gérer les erreurs Règles Le bloc try contient le code à risque susceptible de générer des erreurs Les blocs catch correspondent chacun à une erreur particulière et contiennent le code à exécuter si elle survient

58 Ca mord? Catch me if you can Syntaxe try { // code a risque... } catch ( const exception & e ) {... } catch ( const exception & e ) {... } 4 5 6

59 Ca mord? Catch me if you can Lorsqu'une exception survient (est levée), un objet du type correspondant est crée. C'est lui qui est passé au bloc catch. Génération d'erreur Pour lever une exception, on utilise le mot clé throw : throw exception ; où exception est un objet quelconque, ou même un type de base. C'est l'objet exception qui est récupéré dans le catch

60 Ca mord? Catch me if you can Exemple : class pile_pleine_exception { protected : int taille ; public : 4 pile_pleine_exception ( int taille = -) { 5 this -> taille = taille ; 6 } 7 void afficher_message_erreur () const { 8 cout << " I m p o s s i b l e d ' a j o u t e r un element dans l a 9p i l e " cout << ", t a i l l e "; if ( taille == -) cout << " inconnue "; else cout << taille ; cout << " d e p a s s e e " << endl ; } virtual ~ pile_pleine_exception () { } };

61 Ca mord? Catch me if you can // dans la classe pile : void pile_entier :: empiler ( int donnee ) { if ( index_courant <= taille ) { pile_pleine_exception ppe ( taille ); throw ppe ; // ou juste : throw pile_pleine_exception ( taille ); } }

62 Ca mord? Catch me if you can pile_entier pile (5); try { for ( int i = 0; i < 0; ++i) pile. empiler (i ); for ( int j = 0; j < 5; ++j) pile. depiler (); } catch ( const pile_pleine_exception & ppe ) { cout << " Erreur : "; ppe. afficher_message_erreur ; } catch ( const pile_vide_exception & pve ) { //... }

63 Ca mord? Catch me if you can La hiérarche des exceptions est déterminante. Un catch(un_type une_exception) marche pour toute exception lle de un_type. Ainsi l'ordre des catch est "imposé" (dans le cas contraire, ça compile quand même, avec des warning), en remontant de bas en haut dans l'arbre généalogique.

64 Ca mord? Catch me if you can Il y a également une syntaxe spéciale : catch(...) Pour attraper n'importe quelle exception, on peut utiliser : try { // code a risque } catch ( exception_truc et ) { ; } catch ( exception_machin em ) { ; } catch (...) { cout << " Erreur imprevue! " << endl ; } 4 5 6

65 throw et throws Catch me if you can On peut limiter les exceptions qu'une fonction peut lever via le motclé throw, dans sa dénition.

66 throw et throws Catch me if you can Throws Le mot-clé throw dans le prototype d'un fonction, suivi d'une liste d'exception, signie : je ne risque de lever que ces exceptions là. Si, directement ou indirectement, une autre exception est levée, elle ne pourra pas être traitée via un block try/catch.

67 throw et throws Catch me if you can Syntaxe type nomfonction throw ( exception, exception,...) { instructions ; } 4 Comme pour les catch, la hiérarchie est prise en compte. Ainsi un throw exception marche également avec les classes lles de exception

68 throw et throws Catch me if you can Exemple class exception {... }; class exception {... }; class lanceur { public : void lancer_exception_ok () throw ( exception, exception ) { throw exception (); } void lancer_exception_non () throw ( exception ) { throw exception (); } };

69 throw et throws Catch me if you can try { lanceur (). lancer_exception_ok (); } catch ( const exception & e ) { cout << " e x c e p t i o n! " << endl ; } catch ( const exception & e ) { cout << " e x c e p t i o n! " << endl ; } try { lanceur (). lancer_exception_non (); } catch ( const exception & e ) { cout << " e x c e p t i o n! " << endl ; } catch ( const exception & e ) { cout << " e x c e p t i o n! " << endl ; }

70 throw et throws Catch me if you can Par défaut, absence de throw = peut lever toute exception un throw() (vide) signie : je ne peux lever aucune exception

71 Exemple Les template Chaînes de caractères Les entrées-sorties Les template permettent de manipuler des types de données génériques, sans savoir précisement ce qu'ils sont. Voyons ça avec un exemple :

72 Exemple Les template Chaînes de caractères Les entrées-sorties Une pile générique (pas que pour les int) template < class T > class pile <T> { public : int taille, index_courant ; T donnees []; pile () { taille = 0; donnees = new T [0]; } //... T depiler () { return donnees [ index_courant - -]; } };

73 Exemple Les template Chaînes de caractères Les entrées-sorties Si l'on doit implémenter les méthodes autre part que dans le prototype, il faut remettre template à chaque fois : template < class T > void pile <T >:: empiler (T valeur ) { donnees [++ index_courant ] = valeur ; } 4

74 Exemple Les template Chaînes de caractères Les entrées-sorties Utilisation : pile <int > pile_entier ; pile < double > pile_double ; pile_entier. empiler (5); pile_double. empiler (.5); 4

75 ? Les template Chaînes de caractères Les entrées-sorties La (Standard Template Library) est la librairie standard du C++, qui fournit des classes et des fonctions portables et génériques pour les opérations courantes en programmation

76 la classe string Les template Chaînes de caractères Les entrées-sorties En C++, on utilise la classe std : :string pour manipuler les chaînes de caractères. Elle redénit de nombreux opérateurs de sorte que leur manipulation est assez aisée et intuitive.

77 la classe string Les template Chaînes de caractères Les entrées-sorties # include < string > using namespace std ; //... // initialisation 4 string chaine ; 5 string chaine (" b i j o u r! " ); 6 string chaine = " s a l u t! "; 7 chaine = chaine + chaine ; // concatenation 8 if ( chaine == " b i j o u r! ") 9 cout << "bah bien s u r que c h a i n e vaut b i j o u r! "; 0 cout << chaine. size (); // taille cout << chaine []; // affiche le e caractere de chaine const char * c_chaine = chaine. c_str (); // conversion en chaine C // plus des methodes de traitement standard, recherche, etc...4

78 Les stream Les template Chaînes de caractères Les entrées-sorties Les classes de base pour les entrées/sorties sont ostream (output stream) et istream (input stream). Ils dénissent les fonctions de base pour écrire, lire et gérer le tampon. Voici les fonctionnalités de base :

79 Les stream Les template Chaînes de caractères Les entrées-sorties L'opérateur (sur ostream) pour écrire des données formatées L'opérateur (sur istream) pour lire des données formatées déjà dénis pour la plupart des types courants, mais peuvent être surchargés pour vos types personnels des fonctions plus classiques (write, read, close, etc...)

80 Les stream Les template Chaînes de caractères Les entrées-sorties Les stream courants : ceux de la console : cout (cerr, clog) et cin les ux de chiers : ifstream, ofstream dans l'en-tête fstream Exemple d'utilisation : ifstream fichier_donnees (" mon_ fichier. t x t "); int entree ; fichier_donnees >> entree ; fichier_donnees. close (); ofstream fichier_sortie ; fichier_sortie. open (" s o r t i e. t x t " ); fichier_sortie << "Nombre l u : " << entree << endl ; fichier_sortie. close ();

81 Les container Les template Chaînes de caractères Les entrées-sorties La fournit une implémentation de la plupart des structures de données usuelles : listes, vecteurs, piles, map... sous forme de classes template.

82 Les container Les template Chaînes de caractères Les entrées-sorties Exemple d'utilisation d'un vecteur (sorte de liste) : vector < string > liste ; liste. push_back (" S a l u t " ); liste. push_back (" Machin"); liste. push_back (" B i j o u r " ); cout << liste [] << endl ; cout << " T a i l l e : l i s t e. s i z e ( ) " << endl ; 4 5 6

83 Les container Les template Chaînes de caractères Les entrées-sorties Les itérateurs permettent de parcourir une structure de donnée linéairement. L'exemple est avec vector, mais ils marchent sur les autres types de la même façon : for ( vector < string >:: iterator it = liste. begin (); it!= liste. end (); it ++) cout << (* it ) << endl ;

84 Pour nir Les template Chaînes de caractères Les entrées-sorties Entraînez vous, documentez vous par vous même sur le web (cf sites données lors de la première formation). Pour la, deux references sont disponibles : http :// http ://