Le langage C++: comment ça marche?

Le langage C++: comment ça marche? Jerome.Novak@obspm.fr http://luth.obspm.fr/article403.html Laboratoire Univers et Théories (LUTH) CNRS / Observatoire de Paris / Université Paris Diderot Master 2 e année recherche, Septembre 2015

Plan 1 : Pourquoi le C++? 2 La syntaxe (premiers pas) 3 : orientation objet 4 5 Héritage et polymorphisme 6 Pour aller plus loin...

1 Pourquoi le C++? 2 État des lieux 3 Quelques notions pour démarrer 4 Un avant-goût des classes

Intérêt du C++? langage orienté objet gestion dynamique de la mémoire écriture du code très rigoureuse possibilité d incorporer des routines en C ou fortran possibilité de compiler les programmes C, avec le compilateur C++ compilateurs disponibles et fiables (même gratuits!) norme respectée (norme 2011?) nombreuses bibliothèques existence d outils pour le développement, l optimisation,... (Valgrind, Doxygen,...)

Pour et contre... Pour pouvoir gérer les codes complexes Pour travailler à plusieurs sur un même projet (collaborateurs, visiteurs,...) Pour réduire le temps de développement, de correction et de test. Mais Apprentissage long et complexe Légère perte en vitesse d exécution

... et ça marche! Certains codes n auraient jamais pu être écrits en fortran ou en C...

Une organisation possible pour un projet complexe Python, perl,... Organisation des codes : données initiales, évolution, post-traitement, gestion des entrées/sorties complexes, affichage, visualisation,... C++, java,... Organisation des objets : concepts mathématiques / physiques, structures de stockage, grands groupes d opérations,... C, fortran,... Opérations élémentaires : algèbre linéaire, transformées de Fourier, Newton-Raphson,...

Quelques documents utiles Un serveur de documents et de ressources sur le C/C++ : www.cplusplus.com ; Le cours de C++ du Laboratoire Jacques-Louis Lions (labo d analyse numérique de Jussieu) sur www.ljll.math.upmc.fr/courscpp. LE manuel de référence : Le langage C++, de Bjarne Stroustrup, Eds. Vuibert. Un livre très complet : Langage C++ Le standard ANSI/ISO expliqué, de Jacquelin Charbonnel, Eds. Dunod. Mon petit poly en anglais : www.lorene.obspm.fr/cpp digest.pdf.

Où va-t-on? un cours théorique ( 8 h), des TP d application directe et de familiarisation ( 12 h), des TP de conception de codes plus élaborés, qui seront éventuellement utilisés pour le projet de modélisation numérique (s il reste du temps!!).... le tout mélangé au cours des séances. Objectif des TP élaborés : Résoudre une équation différentielle du second ordre à coefficients ants avec second membre.

État des lieux compilateur (compilation, lien) système Unix/Linux (base, éditeur, makefile,...) programmation (pointeurs, programmation orientée objet) C++...

Quelques notions pour démarrer programme/sous-programme fonctions en C/C++ variables types pointeurs références tableaux fonctions allocation dynamique de mémoire et des conventions : déclaration définition concepteur/utilisateur

Illustration Un code qui ne sert à rien : exemple1.cpp // headers C++ #include <iostream> #include <fstream> // headers C #include <cstdlib> #include <cmath> // // headers maison #include "ma_fonction.h using namespace std ; /* Ce programme ne fait pas grand chose, sinon de montrer une syntaxe "de base" */ int main(){ int nmax = 200 ; double tableau1[nmax] ; char dim[] = "taille" ; //Il faut mettre la les fichiers declarant //des fonctions et classes qui ne font pas //partie du systeme. cout << "Entrez une "<< dim << " de tableau entre 1 et 200" << endl ; int taille ; cin>>taille ;

Illustration Un code qui ne sert à rien : exemple1.cpp if ((taille<1) (taille>200)) { cout << "la " << dim <<" doit etre entre 1 et 200!" << endl ; cout << "autre tentative: " ; while ((taille<1) (taille>200)) cin>>taille ; } double *tableau2 = new double[taille] ; for (int i=0; i<nmax; i++) { int carre = i*i ; tableau1[i] = carre ; } double cube ; for (int i=0; i<taille; i++) { cube = pow(double(i),3) ; //Conversion d un entier en double tableau2[i] = cube + ma_fonction(tableau1[i], taille) ; } cout << "la valeur de tableau2 est: " << tableau2 << endl ; cout << "son premier element vaut: "<< *tableau2 << " ou encore: " << tableau2[0] << endl ; delete[] tableau2 ; return EXIT_SUCCESS ; // SI on est la, c est que tout est bien fini! } // definition de "ma_fonction" double ma_fonction(double x, int n) { double resu = log(x+n) ; return resu ; }

Illustration Un code qui ne sert à rien : ma fonction.h // declaration seule d une fonction double ma_fonction(double, int) ;

TP n o 1 Le programme bonjour le Monde! Objectifs : 1 se familiariser avec l environnement... 2 compiler avec un Makefile 3 écrire et exécuter un programme affichant une phrase et effectuant un calcul après l entrée des données par l utilisateur 4 enfin, ce programme ruira un tableau de taille donnée par l utilisateur au moment de l exécution

C++ C amélioré? pas seulement! langage très typé, même pour les pointeurs utilisation de références surcharge de fonctions utilisation de classes...... et de patrons (modèles) de classes, de fonctions.

: le début Une classe contient des données (variables de types pré-définis ou autres classes) et des fonctions. Elle est la généralisation du concept de type dans les langages informatiques. Pour les classes simples, les données représentent l information contenue dans la classe et les fonctions décrivent à l ordinateur la façon de la gérer. Il existe quatre fonctions obligatoires : le ructeur par défaut le ructeur par recopie le destructeur l opérateur d affectation

// Declaration de la classe "Ma_classe" #ifndef MA_CLASSE_H_ // Pour eviter les declarations multiples #define MA_CLASSE_H_ // headers C++ #include <iostream> // Eventuellement <fstream>, <iomanip>,... // headers C #include <cassert> // + headers perso s il y en a... #include "???" using namespace std ; class Ma_classe { // Donnees : protected: int entier_membre_1 ; double reel_membre_1 ; //etc... // Constructeurs public: Ma_classe(char*, int, double,...) ; // Constructeur standard Ma_classe( Ma_classe& ) ; // Constructeur par copie // Destructeur virtual ~Ma_classe() ; // Operateur d affectation void operator=( Ma_classe&) ; // Affichage (non obligatiore, mais tres utile) friend ostream& operator<<(ostream&, Ma_classe& ) ; }; #endif

// Definition de Ma_classe // headers perso : les headers C++ / C sont inclus dans ma_classe.h #include "ma_classe.h" // Constructeur Ma_classe::Ma_classe() { // Eventuellement avec des parametres cout << "Const. par defaut Ma_classe inexistant" << endl ; } // Constructeur par Copie Ma_classe::Ma_classe( Ma_classe & titi) { cout << &titi << "Const. par recopie Ma_classe inexistant" << endl ; } // Destructeur Ma_classe::~Ma_classe() { cout << "Destructeur Ma_classe inexistant" << endl ; } // Operateur d affectation void Ma_classe::operator=( Ma_classe & titi) { cout << &titi << "operator= pour Ma_classe inexistant" << endl ; } // Affichage a l ecran ostream& operator<<(ostream& o, Ma_classe & titi) { cout << &titi << "operator<< inexistant ds. Ma_classe " << endl ; return o ; }

: un exemple Une classe Fiche contient : le nom de type chaîne de (char*) le prénom de type chaîne de (char*) l âge de type entier (int) le numéro de type entier (int)

fiche.h // Declaration de la classe "Fiche" #ifndef FICHE_H_ #define FICHE_H_ // headers C++ #include <iostream> // headers C #include <cassert> using namespace std ; class Fiche { // Donnees : protected: char* nom ; char* prenom ; int age ; int matricule ; // Constructeurs public: Fiche( char* nom_i, char* prenom_i, int age_i, int matricule_i) ; // Constructeur standard Fiche( Fiche& fiche_arg) ; // Constructeur par copie // Destructeur virtual ~Fiche() ; // Operateur d affectation void operator=( Fiche& fiche_arg) ;

fiche.h // Acces aux donnees... //... en lecture seule char* lit_nom() ; char* lit_prenom() ; int lit_age() ; int lit_matricule() ; //... en lecture / ecriture void change_nom( char* nom_i) ; void change_prenom( char* nom_i) ; void change_age(int age_i) ; void change_matricule(int matricule_i) ; // Affichage (non obligatiore, mais tres utile) friend ostream& operator<<(ostream&, Fiche& fiche_arg) ; }; #endif

fiche.cpp // Definition de Fiche #include <cstring> #include "fiche.h" // Constructeur Fiche::Fiche( char* nom_i, char* prenom_i, int age_i, int matricule_i): nom(0x0), prenom(0x0), age(age_i), matricule(matricule_i) { int l_nom = strlen(nom_i) + 1; nom = new char[l_nom] ; strcpy(nom, nom_i) ; } int l_pnom = strlen(prenom_i) + 1 ; prenom = new char[l_pnom] ; strcpy(prenom, prenom_i) ; // Constructeur par Copie Fiche::Fiche( Fiche & fiche_arg) : nom(0x0), prenom(0x0), age(fiche_arg.age), matricule(fiche_arg.matricule) { int l_nom = strlen(fiche_arg.nom) + 1 ; nom = new char[l_nom] ; strcpy(nom, fiche_arg.nom) ; } int l_pnom = strlen(fiche_arg.prenom) + 1 ; prenom = new char[l_pnom] ; strcpy(prenom, fiche_arg.prenom) ;

fiche.cpp // Destructeur Fiche::~Fiche() { if (nom!= 0x0) delete [] nom ; if (prenom!= 0x0) delete [] prenom ; } // Operateur d affectation void Fiche::operator=( Fiche & fiche_arg) { if (nom!= 0x0) delete [] nom ; int l_nom = strlen(fiche_arg.nom) + 1 ; nom = new char[l_nom] ; strcpy(nom, fiche_arg.nom) ; if (prenom!=0x0) delete [] prenom ; int l_pnom = strlen(fiche_arg.prenom) + 1 ; prenom = new char[l_pnom] ; strcpy(prenom, fiche_arg.prenom) ; age = fiche_arg.age ; matricule = fiche_arg.matricule ; return ; } char* Fiche::lit_nom() { return nom ; } char* Fiche::lit_prenom() { return prenom ; } int Fiche::lit_age() { return age ; } int Fiche::lit_matricule() { return matricule ; }

fiche.cpp void Fiche::change_nom( char* nom_i) { if (nom!= 0x0) delete [] nom ; int l_nom = strlen(nom_i) + 1 ; nom = new char[l_nom] ; strcpy(nom, nom_i) ; } return ; void Fiche::change_prenom( char* prenom_i) { if (prenom!=0x0) delete [] prenom ; int l_pnom = strlen(prenom_i) + 1 ; prenom = new char[l_pnom] ; strcpy(prenom, prenom_i) ; } return ; void Fiche::change_age(int age_i) { age = age_i ; } void Fiche::change_matricule(int matricule_i) { matricule = matricule_i ; } // Affichage a l ecran ostream& operator<<(ostream& o, Fiche & fiche_arg) { o << "Fiche de " << fiche_arg.prenom << " " << fiche_arg.nom << endl ; o << "Age : " << fiche_arg.age << endl ; o << "No. matricule : " << fiche_arg.matricule << endl ; return o ; }

programme principal Exemple // headers systeme #include<cstdlib> // headers maison #include "fiche.h" int main(){ int longueur = 30 ; char un_nom[longueur] ; cout << "Entrez le nom : " ; cin >> un_nom ; char un_prenom[longueur] ; cout << "Entrez le prenom : " ; cin >> un_prenom ; cout << "Entrez l age : " ; int un_age ; cin >> un_age ; cout << "Entrez le matricule : " ; int un_matricule ; cin >> un_matricule ; Fiche f1(un_nom, un_prenom, un_age, un_matricule) ; cout << f1 ; return EXIT_SUCCESS ; }

TP n o 2 une classe simple de rationnels 1 ruire une classe rationnel qui représente un nombre du type a/b, où a et b sont des entiers. 2 doter la classe rationnel de l arithmétique exacte des rationnels. 3 être capable d afficher le résultat d un calcul du genre : rationnel(420,315) + 5 qui soit plutôt 19/3... Il faut commencer par concevoir la classe, ce qui se fait le mieux en écrivant les déclarations. expliquer à l ordinateur comment va fonctionner ce nouveau type.

Le programme principal #include<cstdlib> //Declarations of the class rational #include "rational.h" int main(){ rational p(420,315) ; cout<< p + 5<< endl ; return EXIT_SUCCESS ; } // 420/315, simplified // by the ructor // call to operator+ //and operator<<

(premiers pas) 1 de variables 2 3 4 Les pointeurs, références et allocation de mémoire 5 Les entrées/sorties basiques 6 Les antes NB : tout ce qui marche en C, marche aussi en C++!

de variables int annee=2015 ; float epsilon1=1e-8 ; double epsilon2=1e-16 ; char lettre= w ; bool condition=true ; Les variables peuvent être déclarées à n importe quel endroit du code, mais elles doivent toujours être déclarées avant leur utilisation. La portée d une déclaration est locale, c est-à-dire elle ne vaut que dans le bloc {... } où elle a été faite.

Tout doit être déclaré : double Tchebychev (double x, int degre) ; : d abord dans les en-têtes (fichiers.h) de tous les programmes (routines) qui vont l utiliser, déclaration (attention aux déclarations multiples!) puis elle doit être programmée dans un fichier.c (ou fichier.cpp) définition Si la fonction ne retourne rien (par exemple affichage) elle est de la forme void affiche (Matrice& T) ; mathématiques (sin, cos, log, pow, exp, sqrt, fabs,...) sont déclarées dans <cmath> On peut aussi définir une fonction dans le fichier.h (inline).

Arguments par défaut Certains arguments d une fonction peuvent prendre souvent la même valeur. Pour ne pas avoir à spécifier ces valeurs à chaque appel de la fonction, le C++ permet de donner des valeurs par défaut dans la déclaration de la fonction (ils doivent être mis à la fin de la liste!). void affiche(int valeur, int base = 10); void main() { affiche(16) ; // affiche 16 en base 10 affiche(16,2) ; // affiche 16 en base 2 } et dans la définition : void affiche(int valeur, int base) {... }

for(int i=0; i<val max; i++) {... } if (condition) {... } else {... } while (condition) {... } do {... } while (condition) switch(un entier par ex) case 1: {... break ;} case 2: {... break ;}... default: {... break ;} Où une condition est un bool ou une expression du genre (a==1)&&(b<1e-5)

Un pointeur sur une variable est l adresse en mémoire de cette variable : int g ; int *point = &g ; point contient l adresse de g, il est de la forme 0x0045a3f9 (en hexadécimal). En C++ un pointeur est typé : un int * n est pas compatible avec un double *. Par défaut, un pointeur pointe sur 0x0 (pointeur nul)

Tableaux Un tableau est un pointeur sur le premier élément. int tab[10]; tab est du type int * et contient l adresse du premier élément (tab[0]). Dans ce type de déclarations (double tab[n]), N doit pouvoir être calculé à la compilation (allocation statique). Avec : int *ptr = tab ; ptr++ ; que vaut ptr[0]? NB : On peut définir int tab3[n3][n2][n1]

Gestion dynamique de la mémoire Pour avoir un tableau de taille définie au cours de l exécution (par exemple, donnée par l utilisateur), il faut faire des allocations dynamiques : type *tab dynamique ; tab dynamique = new type[un entier] ; Cet espace de la mémoire DOIT être rendu quand on ne s en sert plus (à défaut, à la fin du programme) par : delete[] tab; Il n y a aucun contrôle sur l accès aux éléments d un tableau. la gestion dynamique de la mémoire est délicate. Il est bon de bien séparer les parties concepteur/utilisateur et d utiliser des outils de développement.

double a; double& ref a = a désigne une référence sur a, il s agit d un synonyme (ou équivalent) de a. Les références sont surtout utilisées pour passer des arguments aux fonctions, ou pour la valeur de retour des fonctions (à éviter). On ne peut pas déclarer int &a seul, mais on utilise : void swap(int &x, int &y) { int z = x ; x = y ; y = z ; } et dans le programme principal : int a=1; int b=2 ; swap(a,b) ; Contrairement aux pointeurs, toute modification de la référence modifie aussi l objet original!

valeur, pointeur et référence En C++, il existe trois façons d accéder à une variable. Après avoir déclaré int a; soit par sa valeur a = 5; cout << a ; par un pointeur int *pa = &a ; *pa = 7 ; cout << *pa ; par une référence int& ra = a ; ra = 11 ; cout << ra ;

Entrées et sorties simples dispose de flots d entrées/sorties standards, déclarés dans <iostream> (il faut aussi déclarer : using namespace std ;) cout qui correspond à la sortie standard ( à l écran ), cin qui correspond à l entrée standard. On écrira donc : int n; cout << "Entrez n" << endl ; cin >> n ; "endl" est ici un manipulateur qui est équivalent à une fin de ligne.

Les antes Elles sont obligatoires pour les dimensions des tableaux non-dynamiques. Elles sont fortement conseillées pour protéger les variables en écriture. Plus concrètement : double est un cas particulier de double. int *ptr veut dire que la variable pointée est ante, mais pas l adresse. Pour cela, il faut écrire int * ptr int& ref est similaire au cas des pointeurs : la variable référencée ne peut pas être modifiée à travers cette référence.

orientation objets 1 : données et fonctions 2 obligatoires 3 Restrictions d accès aux membres 4 Surcharge de fonctions 5 Membres ants 6 TP n o 3 : une classe de stockage de réels

données et fonctions Le programmeur peut définir ses propres types et les fonctions qui leurs sont associées. Une classe Alpha est ainsi ituée : de données : variables, pointeurs, tableaux... ou d objets d autres classes! et de fonctions. Ce sont les membres de la classe Alpha. (données et fonctions) définissent une classe. La déclaration d un objet de la classe s appelle une instance de la classe.

Implémentation d une classe Déclaration class Alpha { int entier1 ; // les données... double reel1 ; Beta autre objet ; int *tableau ; //alloué dynamiquement par le ructeur ou une fonction membre... double fonction1( int&) ; Alpha *fonction2(double, Gamma&) ;}; Définition Si elle n est pas dans le bloc de déclaration : double Alpha::fonction1( int& i) {... } et on peut utiliser le pointeur this ainsi que tous les membres.

Utilisation Dans le programme principal, l utilisation d une classe se fait de la manière suivante (après l avoir déclarée) : Alpha a; //instance de Alpha Alpha *pta ; // pas instance de Alpha a.reel1 = 1.2 ; pta->entier1 = 37 ; double d = a.fonction1(3) ; Gamma g; a = *pta->fonction2(3.4, g) ;

Membres obligatoires Dans chaque classe il faut qu il y ait 4 fonctions membres spéciales, sinon, elles seront créées par le compilateur... au moins un ructeur (autre que copie) un destructeur un ructeur par recopie un opérateur d affectation (copie sans création) Il faut déclarer, puis définir ces fonctions membres, sauf si vous savez exactement ce que va faire le compilateur (et que ça vous va...).

ructeurs Ce sont les fonctions membres qui ruisent les données (ils peut y en avoir plusieurs). Ils n ont pas de type de retour (même pas void!). Ils portent le même nom que la classe qu ils peuvent ruire. Ils se différencient par la liste de leurs arguments. Initialiser les données membres sur l en-tête du ructeur (liste d initialisation) : Alpha::Alpha(double a, int n, Beta &b):entier1(n), reel1(a), autre objet(b) {... } Remarque : il n est pas nécessaire que ce soit le ructeur qui alloue toute la mémoire dynamique de l objet.

copie et affectation ructeur par recopie C est un ructeur de la forme : Alpha::Alpha( Alpha&) {... } qui recopie membre à membre. opérateur d affectation Ce n est pas un ructeur, il se contente de recopier les membres d un objet dans ceux d un autre existant déjà : Alpha::operator=( Alpha&) {...}

le destructeur Un destructeur est une fonction membre spéciale appelée automatiquement juste avant la destruction d un objet. Il porte le même nom que la classe, précédé du signe. Il n a pas d argument, ni de type de retour. Il donne au programme une dernière occasion de libérer la mémoire allouée à l objet. Une classe ne peut avoir qu un seul destructeur. Alpha::~Alpha() {... }

Restriction d accès aux membres Tous les membres ne sont pas accessibles par l utilisateur d une classe. C est le concepteur (programmeur) de cette classe qui décide quels membres pourront être manipulés directement par l utilisateur. Il existe trois types d accès : l accès public : tout le monde a accès, l accès protected : les fonctions membres de la classe et des classes dérivées ont accès, l accès private : seules les fonctions membres de la classe ont accès. Il faut mettre le mot-clef correspondant au type d accès avant les membres dans la déclaration de la classe (.h).

Déclaration de type d accès public: double fonction1... Ce type d accès vaut pour tous les membres jusqu à la rencontre d un nouveau mot-clef. Par défaut, les membres sont privés. fonctions et classes amies Ce sont des fonctions (ou des classes) qui ont libre accès aux membres privés ou protégés. Elles sont déclarées au même endroit que les membres : friend double fonction pote( char*) ; friend class Gamma ;

Surcharge des fonctions Une fonction n est pas entièrement déterminée par son nom, mais aussi par les types de ses arguments. Par exemple, operator +(...) ne fait pas la même chose avec des entiers et des réels. Le programmeur peut redéfinir (surcharger) les opérateurs et les fonctions avec d autres arguments. fonctions membres d une classe (ructeur, opérateurs arithmétiques, etc...). Le lien avec la bonne fonction est fait par le compilateur.

Membres ants Les données membres antes suivent les mêmes règles que les variables antes (elles sont initialisées dans les en-têtes des ructeurs). Une fonction membre ante (par exemple de Alpha) se déclare : double fonction1( int&) ; c est une fonction qui ne modifie pas le données membres de la classe. membres antes sont les seules à pouvoir être appelées sur des objets (de la classe Alpha, dans notre exemple) ants.

Données membres mutables La notion de ance peut correspondre à deux concepts différents : ance physique : l objet conserve sa valeur initiale jusqu à sa destruction ( ), ance logique : les utilisateurs perçoivent l objet invariable ( donnée membre mutable). déclarés mutables peuvent être modifiés par toute fonction membre, ante ou non.

TP n o 3 une classe de stockage de réels Objectifs : Concevoir une classe de bas niveau pour représenter des tableaux de réels à 1,2 ou 3 dimensions, avec l espace mémoire alloué de manière dynamique. Cette classe pourra ensuite être utilisée pour stocker les coordonnées des points des grilles numériques, les valeurs des champs physiques en ces points,... Elle fera les vérifications pour en lecture/écriture, afin d éviter les dépassements de tableaux ; Elle possédera une arithmétiques complète et sera définie pour la plupart des fonctions mathématiques usuelles (sin, exp,,...

Programme principal #include <cstdlib> #include <cmath> #include <iostream> #include "tab.h" int main() { Tab tab3d(2, 3, 4) ; tab3d = M_PI ; cout << tab3d ; cout << sin(tab3d) ; Tab mon_tab(5,6) ; for (int i=0; i<mon_tab.get_taille1(); i++) for (int j=0; j<mon_tab.get_taille2(); j++) mon_tab.set(i,j) = double(i-j)/double(i+j+1) ; Tab aut_tab(5,6) ; aut_tab = 1 ; cout << aut_tab ; Tab vec0(6) ; vec0 = 1./3. ; vec0.sauve("tab_sauve.dat") ; Tab vec("tab_sauve.dat") ; cout << vec ; cout << mon_tab / aut_tab ; cout << vec + 1 ; cout << max(mon_tab) << endl ; return EXIT_SUCCESS ; }

Quelques conseils pratiques... 1 Utilisation des références 2 Entrées / sorties avec les fichiers 3 Le mot-clef 4 Conception de classes

Utilisation des références Rappel : Une valeur de type référence (type &) est une adresse, MAIS les modifications sur cette adresse touchent l objet référencé et non l adresse (qui ne peut être modifiée). De plus : le type void & n est pas valide. il est impossible de créer un pointeur sur une référence (mais une référence sur un pointeur, si!), de créer une référence sur une référence, de créer un tableau de références. une référence doit toujours être définie (initialisée).

Valeur, adresse, ou référence? int a est un argument de fonction void f(...). Si la valeur de a doit aussi être retournée par f (de la fonction appelée à la fonction appelante), il faut passer a par adresse (pointeur ou référence) : void f(int *a) ; ou void f(int &a) ;. Sinon, et si la taille de a n est pas plus grande que celle d un entier, on peut passer a par valeur : void f(int a) ;. Attention aux variables de retour!

Piège des renvois de références Ne jamais renvoyer une référence sur un objet détruit à la fin de la fonction appelée : Tab &operator+(tab &t1, Tab &t2) { Tab resu(t1) ;... return resu ; }//!!! Ne pas modifier l objet référencé tant que la référence est utilisée : class pile { public: int &Top() ;// consulte/modifie le sommet int Pop() ;} ; // renvoie la valeur au sommet de la pile et l enlève de la pile. Le problème apparaît pour : pile p; p.top() = p.pop()+1 ;

Entrées / Sorties Rappel : les fonctions du C marchent aussi en C++!! (printf, scanf...). Il existe 4 flux pré-définis, déclarés dans <iostream> : cin, qui correspond à l entrée standard (stdin en C), cout, qui correspond à la sortie standard (stdout en C), cerr, qui correspond à la sortie d erreur (stderr en C), clog, qui est le flux de sortie d erreur tamponnée. cout << "i=" << i << \n ; cerr << "mémoire insuffisante" ; cin >> x >> y ; cout << A ;

Flux associés aux fichiers Il y a deux classes pré-définies dans <fstream> pour gérer les entrées/sorties avec les fichiers : class ifstream pour les entrées, class ofstream pour les sorties. Exemple : ifstream f("entree.dat") ; ofstream g("sortie.dat") ; int n ; f >> n ; g << n << endl ; Une alternative peut être : ifstream f ; f.open("entree.dat"); f.close();...

Méthodes communes aux flux Ces méthodes peuvent être utilisées pour les entrées/sorties standards, comme pour les fichiers : << et >>, qui sont surchargés pour les types standards, put(char c) et write( char *s, int n) en écriture, get(char c), read(char *s, int n), getline(char *s, int, char delim= \n ) et ignore(int n=1, int delim=eof) en lecture.

Manipulateurs Ils sont équivalents aux fonctions membres des flux pour le formattage de l information, mais leur appel est plus simple : dec, hex,... et setbase(int n) (sortie), endl, ends et flush (sortie), setfill(char c), setw(int n), setprecision(int n), fixed, scientific, left, right, uppercase,... (sortie), skipws, noskipws, ws (entrée), tab, decindent, incindent... (sortie).

Manipulateurs exemple d utilisation Comparez : cout.width(10) ; cout.fill( * ) ; cout.setf(ios::hex, ios::basefield); cout <<123 ; cout.flush(); et cout << setw(10) << setfill( * ) << hex << 123 << flush ; qui sortent tous les deux : ********7b

La classe string En C++, il existe une classe string, pour manipuler les chaînes de (#include<string>). ructeurs : string chaine ; string suite = "bonjour" ; accès : chaine.size() ; chaine.length() ; suite[i] ;... manipulation : chaine += suite ; string total = chaine + suite ;... comparaison : chaine.compare(suite) ; récupération du char* : chaine.c str() ; chaine.data() ; (sans le \0 ) autres : find, copy,... Certaines de ces fonctions sont surchargées, avec des arguments supplémentaires permettant de travailler sur une partie de la chaîne de.

Flux d entrée/sortie un exemple complet #include<iostream> #include<fstream> #include<string> #include<sstream> #include <iomanip> using namespace std ; int main() { double mass_b = -1 ; double e1, e2, om1, om2, press, ener, mg, mb1, mb2 ; for (int i=1; i<=15000; i++) { ostringstream oo ; oo << r << setfill( 0 ) << setw(5) << i << ".d" ; cout << oo.str() << endl ; // Affiche de r00001.d a r15000.d ifstream f(oo.str().data()) ; // Ouvre le i-eme fichier f >> e1 ; // prend le premier caractere (ev if (f) { // si le fichier n est pas vide f >> e2 >> om1 >> om2 >> press >> ener >> mg >> mb1 >> mb2 ; } } return EXIT_SUCCESS ; }

Utilisation de Quand faut-il déclarer un argument de fonction ant? Dès que la fonction n a besoin que de lire la valeur de cet argument (elle ne le retourne pas...) sans objet pour les valeurs. Si une classe n a aucune fonction membre prenant des antes, il sera difficile d instancier des objets ants de cette classe. Le ructeur par recopie et l opérateur d affectation doivent prendre des arguments. Quand une fonction prends des objets, elle peut aussi prendre des non-!

Utilisation de Quand une fonction membre doit-elle être ante? membres antes ne modifient pas les données de la classe sur laquelle elles sont appelées. Il faut faire appel au maximum à celles-ci, en faisant attention qu elles soient vraiment antes. Éventuellement, on peut déclarer des données mutable. Renvoi de ante par une fonction membre? Dès que la fonction membre renvoie une référence (attention!) ou un pointeur sur une donnée membre ante!

Conception de classes Optique de la programmation par objets encapsulation : regrouper dans une même classe les structures de données (les données membres) et les fonctions qui les manipulent. abstraction de données : Bien séparer une partie privée et une partie publique. La partie privée contient les structures de données et les fonctions à usage interne. La partie publique contient les fonctions et variables offertes aux utilisateurs de la classe. On appelle interface de la classe ce qui est accessible par tout le monde et implémentation ce qui ne l est que par le concepteur.

Conception de classes Les ructeurs Pour tous les ructeurs (y compris les ructeurs par recopie), privilégier la liste d initialisation à la recopie dans le corps de la méthode. Définir un ructeur pour les classes dérivées : en effet, si la classe de base a un ructeur déclaré, la classe dérivée n a pas de ructeur par défaut (synthétisé). Si, parmi les données membres de la classe, il y a une ante ou une référence, il n y a pas de ructeur par défaut synthétisé par le compilateur. toujours déclarer au moins un ructeur, même s il ne fait rien!

Conception de classes operator=, ructeur par recopie et destructeur Un destructeur ne fait rien, sauf si la classe contient des objets alloués dynamiquement. Il peut être utile de déclarer le destructeur virtual, que la classe fasse appel à l héritage ou non. nécessité du ructeur par recopie A chaque appel d une fonction ayant pour argument un membre de la classe, il y a duplication de cet argument. Le ructeur par recopie synthétisé ne copie pas les tableaux dynamiques, ni les objets externes à la classe (par ex : les FILE *). opérateur d affectation Il ne crée pas l objet, mais ne fait que copier ses membres. Comme l objet existe déjà, il doit le nettoyer ou vérifier qu il est compatible...

Conception de classes Affichage Parmi les fonctions membres, en plus des 4 fortement conseillées, il est souvent très commode de définir un opérateur d affichage : (friend) ostream& operator<<(ostream& o, Alpha& a) { o << "ceci est un objet de la classe Alpha" << endl ; o << a.donnees membres << endl ;... return o ; } qui est ensuite utilisé simplement : Alpha a; cout << a ;

Héritage et polymorphisme 1 Héritage simple 2 Héritage multiple 3 Polymorphisme 4 Exemples : les classes Etoile et Eos 5 TP n o 4 : une classe de matrices

Héritage simple L héritage permet d utiliser les propriétés (données et fonctions membres) d une classe existante en les enrichissant pour faire une nouvelle classe. class A ; class B : public A {... } ; B (classe dérivée) est une sorte de A (classe de base). Les ructeurs, ructeur par copie, opérateurs d affectation (tous) et destructeurs ne sont pas hérités. Il faut créer un ructeur avec une liste d initialisation (en-tête) : B::B(...):A(...), données membres de B(...),... {... } ;

Compatibilité implicite Par un héritage publique, une classe B dérivée de A offre les mêmes services que A. Un objet de type B peut remplacer un objet de type A. Cela peut être utilisé avec des pointeurs ou des références : A a, *pa ; B b, *pb ; pa = &b ; // mais pas pb =&a!! Le type statique de pa est A *, le type dynamique de pa est B *.

Types d héritage Dans l exemple précédent, B hérite de façon publique de la classe A. Il est possible de décider du type d héritage à l aide de l un des mots-clés : public : les membres hérités gardent les mêmes restrictions d accès que dans la classe de base, protected : les membres hérités sont en accès protected, private : les membres hérités sont en accès private. SAUF les membres privés de la classe de base qui ne sont jamais accessibles dans les classes dérivées (mêmes pas par les fonctions membres!).

Ajustement d accès Lors d un héritage protégé ou privé on peut décider que certains membres de la classe de base conservent leur type d accès dans la classe dérivée. On ne peut en aucun cas augmenter ou diminuer les droits d accès à un membre de la classe de base. class X { public: void f1() ; void f2() ; protected: void f3() ; void f4() ; }; class Y : private X { public: X::f1 ; //mais pas f3! protected: X::f4 ; //f2 et f3 sont privés dans Y };

Classes et fonctions amies amies de la classes de base restent amies des membres hérités, mais pas des nouveaux membres des classes dérivées. amies de la classe de base ne le sont plus du tout (même pas pour les membres hérités) pour la classe dérivée ; il faut redéfinir les relations d amitié avec les fonctions.

Héritage multiple Il permet de créer des classes dérivées utilisant plusieurs classes de bases. class A ; class B ; class C: public B, protected A {... } ; Les ructeurs sont appelés dans l ordre de déclaration de l héritage (celui de B, puis de A, puis de la classe dérivée). Les destructeurs sont appelés dans l ordre inverse de celui des ructeurs.

Héritage virtuel class A {...} ; class B: public A {...} ; class C: public A {... } ; class D: public B, public C {... } ; D contiendra deux fois les données héritées de A... Pour lever l ambiguïté, il faut utiliser l héritage virtuel : class B: virtual public A {... } ; class C: virtual public A {... } ; class D: public B, public C {... } ; Cet héritage virtual ne doit pas être confondu avec les membres virtuels du polymorphisme.

Polymorphisme L idée de l héritage (surtout public) est que si B hérite de A, B est une sorte de A. Il se peut néanmoins, que l on ait envie de redéfinir (ou surcharger) dans B certains membres de A. B::affiche() ; A::affiche() ; différente B b ; A *ptr=&b ; ptr->affiche();?? Au moment de la compilation, il est impossible de savoir quelle fonction appeler.

Liaison dynamique La liaison avec la bonne fonction membre se fait au moment de l exécution. Ce mécanisme se met en place dans la classe de base : class A { public: virtual void affiche() {... } ;...} puis, dans la classe dérivée, il faut déclarer la même fonction membre, avec les mêmes arguments : class B: public A { public: virtual void affiche() {... } ;...}.

Fonctions membres virtuelles pures Certaines fonctions virtuelles sont trop générales pour pouvoir être définies (par exemple, dans la classe Eos). Mais elles sont quand même nécessaires... On peut définir ces fonctions pour qu elles renvoient simplement un message d erreur. Une meilleure solution est de les déclarer virtuelles pures : class A { public: virtual void affiche()=0 ; } Cela signifie que la définition de affiche() est différée et déléguée aux classes dérivées.

Classes abstraites Une classe abstraite est une classe qui ne peut pas être instanciée. C est en général une classe dont l implémentation est insuffisante pour représenter complètement un objet réel. Le rôle de la classe est de servir de moule pour dériver d autres classes. On peut avoir des classes abstraites si tous les ructeurs sont protégés ou privés, si la classe déclare au moins une fonction virtuelle pure, si la classe hérite d une fonction virtuelle pure qu elle ne définit pas. Si A est une classe abstraite, A a ; est illégal A *pta ; est permis.

Exemples : les classes Etoile et Eos Etoile Etoile rot Et rot bifluid Eos(classe abstraite) Eos poly, Eos tabul,...

TP n o 4 : des matrices héritées de la classe de tableaux Objectifs : Concevoir une classe de matrices carrées héritant de la classe de tableaux (Tab) du TP n o 3. Cette classe pourra ensuite être utilisée pour décrire des opérateurs différentiels ou autres... Elle aura des méthodes determinant(), Tab resout( Tab&) et Matrice inverse() éventuellement virtuelles (possibilité de classes dérivées de Matrice (matrices triangulaires, à bandes,...) qui seront définies plus tard Elle devra posséder un produit matriciel s écrivant m1 * m2 ou mat * vec avec vec un Tab à une dimension Note : les méthodes Mat::resout(...), Mat::inverse(...), Mat::determinant(...) ne seront définies qu après le cours sur le liens avec le fortran.

Programme principal #include <cstdlib> #include <iostream> #include "matrice.h" int main() { Tab rhs("memb_droite.dat") ; Matrice mat("matrice.dat") ; double max_rhs = max(abs(rhs)) ; cout << "Maximum du membre de droite: " << max_rhs << endl ; // Le calcul suivant est optionnel (a faire pour les plus forts!) cout << "Determinant de la matrice: " << mat.determinant() << endl ; Tab solu = mat.resout(rhs) ; cout << "Solution: " << solu ; Tab lhs = mat*solu ; double err = max(abs(lhs - rhs)) ; cout << "Erreur absolue: " << err << endl ; cout << "Erreur relative: " << err / max_rhs << endl ; return EXIT_SUCCESS ; }

Pour aller plus loin 1 C++ et fortran 2 Espaces de noms 3 Variables statiques 4 Conversion de types 5 de fonctions 6 Modèles de fonctions et de classes 7 Bibliothèques prédéfinies

Mélanger C++ et fortran Appeler du fortran depuis le C++ Il est possible d appeler des fonctions (ou sous-routines) fortran (66, 77, 95, 2003?) depuis un programme en C++ : Du côté C++, la fonction fortran doit être déclarée avec, éventuellement, un ou deux à la fin de son nom. Le fortran ne travaille qu avec des pointeurs, il faut donc passer toutes les variables par adresse. On ne peut passer que des types simples (int, float, double et char), surtout pas de classe!! Il faut compiler chaque fichier (.cpp ou.f) avec son compilateur et, pour le lien, utiliser le compilateur C++ (le programme principal est en C++!) avec la bonne bibliothèque ( ex : g++ -o prog cmain.o fonc.o -lgfortran pour les compilateurs GNU)