Cours de C++ Guillaume Caumon, Février 2007 Introduction à la Programmation Orientée Objet

Le C++ Introduction Du C au C++ Les Classes Lhéritage Programmation générique

Pourquoi ce cours ? Place importante de la modélisation en Geosciences : - validation dune théorie - prédiction et calculs - évaluation des risques Les phénomènes étudiés sont complexes La programmation orientée-objets peut faire gagner beaucoup de temps

Objectif du cours Connaissance Temps - Comprendre les concepts élémentaires de programmation orientée objet (POO) - Etre capable de lire et comprendre du code C++ - Analyser un problème et le décomposer pour mieux le traiter - Mettre en oeuvre les concepts de POO en langage C++

Agenda Lundi pm : Du C au C++ Mardi am : exercices pratiques Mardi pm : Les classes Mercredi am : Lhéritage Mercredi pm : quizz et exercices Jeudi am : exercices Vendredi am : Bibliothèque std + exercices Vendredi pm : colle (2h)

Bref historique Lalgorithmique est une science ancienne (ex: algorithme dEuclide pour calculer le PGCD) Mais la programmation une science nouvelle (ou un art nouveau ? [Knuth, the Art of Computer programming] ). - Métier à tisser de (1801): ancêtre des cartes perforées (Recencement Brevet IBM 1930) - Développement de programmes assembleur à partir des 40s pgcd(m, n) = pgcd(m n, n) si m > n pgcd(m, n) = pgcd(m, n m) si m < n

Bref historique Difficultés et erreurs Développement de langages pour rendre le codage plus intuitif: Fortran (1950), ALGOL Aujourdhui: - langages procéduraux (Pascal, C,…). - langages fonctionnels (ML, CAML, …). - langages orientés-objet (ADA, SmallTalk, Eiffel, C++, Java, …).

Qualité dun Programme ? 1 Validité Le programme fonctionne 2 Extensibilité Je peux le faire évoluer 3 Réutilisabilité Je peux utiliser des composantes du programme pour dautres applications

Comment sy prendre ? Séparer le programme en modules réutilisables Par analyse fonctionnelle descendante Par analyse ascendante Unité fonctionelle autonome, possédant une interface Independante de son implantation (header.h) (impl.cpp)

On peut le faire en C… Modules = fonctions (déclaration / implementation) Communication entre modules = appels de fonctions Flexibilité et réutilisation par des pointeurs de fonctions MAIS: - Les données sont globales - Comprendre le programme équivaut à comprendre ce que fait chaque fonction

Exemple C / C++ Calcul de distance float hits[3][100] float x,y,z; int i = 0; float dist = 0; … for(i = 0; i < 100; i++ ){ x = hits[i][0]; y = hits[i][1]; z = hits[i][2]; dist = sqrt(x*x + y*y + z* z); } Point points[100]; Point orig(0, 0, 0); … for( i = 0; i < 100; i++ ){ float dist = points[i].distance(origin); } Changer les coordonnées de lorigine ? Passer en référentiel sphérique ?

Différences C / C++ Langages compilés Analyse, mise en oeuvre et architecture des programmes Possibilités de vérifications en C++ lors de la compilation C++ offre des nouvelles possibilités

La conception par objets Cette méthode privilégie les données, et non les fonctions Trouver les objets (physiques) Décrire et classer les objets Implanter ces objets OpérationsLiens Caractéristiques communes

Pourquoi concevoir des objets ? Un être humain peut facilement comprendre simultanément un seul aspect dun problème Diviser pour régner Associer les données et les fonctionnalités Représenter des abstractions Recycler ces abstractions

Un langage orienté objet Permet: La définition dobjets, avec partie publique et privée La modularité (compilation séparée) La réutilisation (mise en facteur des fonctionalités) Lextension des objets (héritage) La lisibilité (distinction interface / implémentation) La définition dobjets abstraits

Exemple : les listes (code C) typedef struct LIST { NODE* p_first_node_ ; NODE* p_first_node_ ; NODE* p_last_node_ ; NODE* p_last_node_ ; int nb_items_ ; int nb_items_ ; } LIST ; LIST* LIST_Create() ; void LIST_Destroy BOOLEAN LIST_Owns_Item typedef struct NODE { struct NODE* next_ ; struct NODE* next_ ; void* p_item_ ; void* p_item_ ; } NODE ; … () ; ( LIST* p_list ) ; ( LIST* p_list, PNTR* item ) ; … Plus explicite… Mais le compilateur C ne peut pas vérifier les types

Exemple : les listes (code C) typedef struct DATA { int index_; int index_; char value_; char value_; } DATA; BOOLEAN check_item( LIST* list, DATA* data ) { BOOLEAN found = LIST_Owns_Item( list, data ); BOOLEAN found = LIST_Owns_Item( list, data ); if( found ) { if( found ) { printf( printf( Item %d, %c in List, Item %d, %c in List, data->index_, data->value_ data->index_, data->value_ ); ); } return found; return found;} Problème: Une fonction par type de donnée…

Exemple : les listes (code C++) class Node { …}; class List { public : List(); List(); ~List(); ~List(); bool owns_item( void* item ) const; bool owns_item( void* item ) const; private : Node* first_node_ ; Node* first_node_ ; Node* last_node_ ; Node* last_node_ ; int nb_items_ ; int nb_items_ ;};

Exemple : les listes (code C++) class Data { public : Data( int index, char value ); Data( int index, char value ); void print() const; void print() const; private : int ind_; int ind_; char val_; char val_;}; bool check_item( List* list, Data* data ) { bool found = list->owns_item( data ); bool found = list->owns_item( data ); if( found ) { if( found ) { data->print(); data->print(); } return found; return found;}

Historique Créé par B. Stroustrup (Bell Labs. ) à partir de 1979 (C with classes). Initialement: code C++ précompilé code C Devient public en 1985 sous le nom de C++. La version normalisée (ANSI) paraît en C++ = C + Vérifications de type + stricte Surcharge de fonctions OpérateursRéférences Gestion mémoire + facile Entrées/sorties + facile Classes et héritage Programmation générique …

Un langage compilé… Langage = protocole de communication entre le programmeur et le processeur. Code C/C++ Code pré-processé Programme Librairies Fichier(s) Objet

Le C++ Historique Du C au C++ Les Classes Lhéritage Programmation générique

Commentaires C /* This is a multi-line C comment */ C++ /* This is just the same in C++, but… */ // … We also have single-line comments Règles : rester cohérent appliquer une norme pour générer de la doc html automatiquement.

Prototypes de fonctions // declaration in a header file. void function( int param1, int param2 = 10 ); header.h // implementation file void function( int param1, int param2 ) { // print param1 and param2 to // the standard output. } impl.cpp // main function int main( int argc, char** argv ) { function( 5, 3 ); function( 5 ); return 0; } client.cpp

Surcharge Surcharge de fonctions int square( int value ); float square( float value ); double square( double value ); header.h Surcharge dopérateurs typedef struct Complex { float x_; float y_; }; Complex& operator+( Complex& lhs, Complex& lhs, const Complex& rhs const Complex& rhs); complex.h Utilisation de Complex comme dun type standard

Surcharge Les types des paramètres peuvent être utilisés pour la surchage, mais pas la valeur de retour. double square( double value ); float square( double value ); Erreur de compilation

Fonctions inlines // declaration inline bool max( int x, int y ); // implementation inline int max( int x, int y ) { return (x > y) ? x : y; } header.h // preprocessor macro #define MAX(x,y) (x > y) ? x : y;

Fonctions inlines void client_function( int a, int b ) { inf c = 0; inf c = 0; if( … ) c = MAX(a+=a, b+=b); // preproc macro if( … ) c = MAX(a+=a, b+=b); // preproc macro else c = max(a+=a, b+=b); // inline function else c = max(a+=a, b+=b); // inline function //… //…} client.cpp void client_function( int a, int b ) { int c = 0; int c = 0; if( … ) c = (a+=a > b+=b) ? a+=a : b+=b; if( … ) c = (a+=a > b+=b) ? a+=a : b+=b; else { a += a; b += b; else { a += a; b += b; c = (a > b) ? a : b; c = (a > b) ? a : b; //… //…} Equivalent client.cpp

Déclaration de variables C++ permet de déclarer des variables nimporte où et de les initialiser. Règles: toujours déclarer ses variables au dernier moment. toujours déclarer ses variables au dernier moment. initialiser TOUTES les variables. initialiser TOUTES les variables. déclarer une variable par ligne. déclarer une variable par ligne.

Constance char* c1; Pointeur variable vers une chaîne de caractères variable. const char* c2; Pointeur variable vers une chaîne de caractères constante. char* const c3; Pointeur constant vers une chaîne de caractères variable. const char* const c4; Pointeur constant vers une chaîne de caractères constante.

Références PointeursRéférences int array[10]; int* pointer = &array[5]; int value = *pointer; *pointer = 100; int array[10]; int& ref = array[5]; int value = ref; ref = 100; Peut changer au cours du temps Ne peut pas changer dobjet Peut être nulRéférence toujours une variable valide, définie lors de la déclaration de la référence

Références PointeursRéférences int a = 10; int* const p = &a; int a = 10; int& r = &a; Référence pointeur non nul qui indique toujours la meme adresse Conséquence : ne pas utiliser des T* const mais des T&, cest plus élégant.

Allocation mémoire C int value = 10; int* var = (int*)malloc(sizeof(int)); *var = value; int* array = (int*)malloc(n*sizeof(int)); C++ int value = 10; int* var = new int( value ); int* array = new int[10]; En C++, les allocations sont typées.

Désallocation mémoire C int* var = (int*)malloc(sizeof(int)); int* array = (int*)malloc(n*sizeof(int)); … free( var ); free( array ); C++ int* var = new int(); int* array = new int[10]; … delete var; delete [] array;

CC++ #include #include printf --> standard output scanf <-- standard input fprintf --> FILE* fscanf char[N] sscanf FILE* fscanf char[N] sscanf <-- char*[N] cout --> standard output cerr --> standard error output cin output file ifstream char*[N] istringstream standard output cerr --> standard error output cin output file ifstream char*[N] istringstream <-- char*[N] ostream& operator<< istream& operator>> Entrées / Sorties (I)

Entrées / Sorties (II) C #include int value = 10; printf( value = %d\n, value ); printf( New value = ??\n ); scanf( %d, &value ); C++ #include using namespace std; int value = 10; cout << Value = << value << endl; cout << New value = ?? << endl; cin >> value; Les opérateurs > sont surchargeables.

Entrées / Sorties (III) C #include FILE* file; if( fopen( file, filename ) ) { fprintf( file, Hello!!\n ); } C++ #include using namespace std; ofstream outfile( filename ); if( outfile.good() ) { outfile << Hello!! << endl; }

Entrées / Sorties (IV) typedef struct Complex { float x_; float x_; float y_; float y_; } Complex; using namespace std; ostream& operator<<( ostream& os, const Complex& z ostream& os, const Complex& z ) { return os << z.x_ << " + return os << z.x_ << " + << z.y_ << * i"; << z.y_ << * i";}

Le C++ Historique Du C au C++ Les Classes Lhéritage Programmation générique

Fonctions et structures struct Date { int year_; int year_; int month_; int month_; int day_; int day_; void print(); void print();}; file.h file.cpp void Date::print() { cout << month_ << / cout << month_ << / << day_ << / << year_ << endl; << day_ << / << year_ << endl;}

Classe C++ : interface /** * A calendar date. * A calendar date. */ */ class Date { public : void set_date( void set_date( int year, int month, int day int year, int month, int day ); ); void print() const; void print() const; private : int year_; int year_; int month_; int month_; int day_; int day_;}; file.h

Classe C++ : implantation file.cpp void Date::set_date( int year, int month, int day int year, int month, int day ) { if( if( month == 2 month == 2 && ! bisextile( year ) && ! bisextile( year ) && day > 28 && day > 28 ) { ) { cerr << Where did you see that\n cerr << Where did you see that\n << February could have << February could have << day << days << day << days << in << year << ! << endl; << in << year << ! << endl; } // etc. // etc.}

Constructeurs / Destructeurs class Date { public : /** /** * Creates a Date from the year, month and day. * Creates a Date from the year, month and day. * if parameters are not consistent, an error * if parameters are not consistent, an error * message is produced. * message is produced. */ */ Date( int year, int month, int day ); Date( int year, int month, int day ); /** Copy constructor */ /** Copy constructor */ Date( const Date& other_date ); Date( const Date& other_date ); /** Destroys this Date */ /** Destroys this Date */ ~Date(); ~Date(); // … // …}; file.h

Constructeurs / Destructeurs file.cpp Date::Date( int year, int month, int day int year, int month, int day ) { set_date( year, month, day ); set_date( year, month, day );} Date::Date( const Date& other ) : year_( other.year_ ), year_( other.year_ ), month_( other.month_ ), month_( other.month_ ), day_( other.day_ ) { day_( other.day_ ) {} Date::~Date() { // nothing to do // nothing to do}

Constructeur par copie ou = ? void printperson( const Person& p ) { Person tmp; Person tmp; tmp = p; tmp = p; cout << "Name: " << tmp.get_name() cout << "Name: " << tmp.get_name() << ", date of birth: " << ", date of birth: " << tmp.get_date_of_birth << endl; << tmp.get_date_of_birth << endl;} void printperson( const Person& p ) { Person tmp( p ); Person tmp( p ); cout << "Name: " << tmp.get_name() cout << "Name: " << tmp.get_name() << ", date of birth: " << ", date of birth: " << tmp.get_date_of_birth() << endl; << tmp.get_date_of_birth() << endl;} file.cpp

Fonctions constantes class Date { public : // … // … /** /** * Prints this date to the standard output. * Prints this date to the standard output. * Format is American: mm/dd/yy * Format is American: mm/dd/yy */ */ void print() const; void print() const; // … // …}; file.h file.cpp void Date::print() const { cout << month_ << / cout << month_ << / << day_ << / << year_ << endl; << day_ << / << year_ << endl;}

Variables statiques class Date { public : // … // … /** To be called once in the program */ /** To be called once in the program */ static void init(); static void init(); private : static bool bisextile( int year ); static bool bisextile( int year ); static int nb_days( static int nb_days( int month, int year int month, int year ); ); private : static int nb_days_per_month_[12]; static int nb_days_per_month_[12];}; file.h

Classes imbriquées class Triangle { public : //… //… class Edge { class Edge { public : public : //… //… Triangle* incident_triangle( Triangle* incident_triangle( int index int index ); ); }; };}; file.h

Relations entre classes class Object { public : //… //… private : ObjectUpdater* updater_; ObjectUpdater* updater_;}; class ObjectUpdater { public : //… //… private : Object* object_; Object* object_;}; file.h

Relations entre classes class ObjectUpdater; class Object { public : //… //… private : ObjectUpdater* updater_; ObjectUpdater* updater_;}; class ObjectUpdater { public : //… //… private : Object* object_; Object* object_;}; file.h

Le C++ Historique Du C au C++ Les Classes Lhéritage Programmation générique

Règles dhéritage Une voiture est un véhicule Vehicle Car class Vehicle { //… //…}; class Car : public Vehicle { //… //…}; file.h

Exemple CircleSquareLine GeomFigure GeomShape

Conversions et classes parentes Base Derived Base y;Derived y; Base& x = y; Derived& x = y; OK NON OK OK

Construire une classe dérivée class Vehicle { public : Vehicle(); Vehicle();}; class Car : public Vehicle { public : Car(); Car();}; file.h file.cpp Car::Car() : Vehicle() { }

public, protected, private public : accessible par tous protected : accessible uniquement par les classes dérivées private : fonctionnement interne à la classe

Surcharge de fonctions class Vehicle { public : float power() const; // returns 0 float power() const; // returns 0}; class Car : public Vehicle { public : float power() const; // returns 100 float power() const; // returns 100}; file.h int main( int argc, char** argv ) { Vehicle v; cout << v.power() << endl; Car c; cout << c.power() << endl; Vehicle& v2 = c; cout << v2.power() << endl; return 0; } file.cpp

Expérience (I) class Employee { public : float income(); // 1000 float income(); // 1000 char* name(); char* name();}; class Boss : public Employee { public : float income(); // float income(); // 10000}; class Company { public : void print_all_incomes(); void print_all_incomes(); void add_employee( Employee* employee ); void add_employee( Employee* employee ); private : Employee** employees_; Employee** employees_; int nb_employees_; int nb_employees_;}; Company Boss Employee

Expérience (II) int main( int argc, char** argv ) { Company company(3); Company company(3); Boss* homer = new Boss( "Homer" ); Boss* homer = new Boss( "Homer" ); company.add_employee( homer ); company.add_employee( homer ); Employee* marge = new Employee( "Marge" ); Employee* marge = new Employee( "Marge" ); company.add_employee( marge ); company.add_employee( marge ); Employee* bart = new Employee( "Bart" ); Employee* bart = new Employee( "Bart" ); company.add_employee( bart ); company.add_employee( bart ); company.print_all_incomes(); company.print_all_incomes(); return 1; return 1;} file.cpp

Expérience (III) void Company::print_all_incomes() { for( int i = 0; i < nb_employees_; ++i ) { for( int i = 0; i < nb_employees_; ++i ) { cout name() cout name() income() income() << endl; << endl; } }} file.cpp

Solution : fonctions virtuelles class Employee { public : virtual float income(); // 1000 virtual float income(); // 1000 char* name(); char* name();}; class Boss : public Employee { public : virtual float income(); // virtual float income(); // 10000}; Company Boss Employee

Exercice class Base { public : virtual void f1(); virtual void f1(); virtual void f2(); virtual void f2();}; obj->f1()obj->f2()obj->f3() Base* obj = new Base; Base* obj = new Derived; Derived* obj = new Base; Derived* obj = new Derived; class Derived : public Base { public : virtual void f2(); virtual void f2(); virtual void f3(); virtual void f3();};

Mécanisme du polymorphisme Base Derived Base::vf1 Base::vf2 Base::vf3 Derived::vf1 Derived::vf3 vtbl_ Base vtbl_

Dérivation et destruction Une classe de base doit toujours avoir un destructeur virtuel. class Vehicle { public : virtual ~Vehicle(); virtual ~Vehicle();}; class Car : public Vehicle { public : virtual ~Car(); virtual ~Car();}; file.h

Construire / Detruire Base Derived Appel des constructeurs destructeurs Règles : Ne jamais appeler une fonction virtuelle dans un constructeur. Ne jamais appeler une fonction virtuelle dans un constructeur. Une fonction virtuelle ne peut pas etre inline Une fonction virtuelle ne peut pas etre inline Toujours utiliser des pointeurs / références pour utiliser le polymorphisme.Toujours utiliser des pointeurs / références pour utiliser le polymorphisme.

Objets virtuels purs Une classe de base peut définir des fonctions sans les implanter. Elle force ainsi limplantation dans ses classes dérivées. class Vehicle { public : virtual ~Vehicle(); virtual ~Vehicle(); virtual float power() const = 0; virtual float power() const = 0; protected : Vehicle(); Vehicle();}; file.h

Philosophie de lHéritage Héritage public est un En dautres termes: Ce qui sapplique a une classe de base sapplique a ses classes dérivées. Question: une classe Carre peut-elle deriver dune classe Rectangle ? Reponse : non ! Ce qui est vrai pour un rectangle nest pas vrai pour un carre.

Philosophie de lHéritage Héritage de linterface Héritage de limplantation Fonction non virtuelle Obligatoire Fonction virtuelle ObligatoirePar défaut, possibilité de redéfinir Fonction virtuelle pure ObligatoireNon, à redéfinir

Le C++ Historique Du C au C++ Les Classes Lhéritage Programmation générique

Paramétrer des classes… Cas dune liste chaînée: les objets de la liste peuvent etre de type différent. ( void* ) template class List { public : List( int nb_items ); List( int nb_items ); ~List(); ~List(); void append_item( const T& item ); void append_item( const T& item ); void remove_item( const T& item ); void remove_item( const T& item ); void remove_all(); void remove_all(); //… //…}; file.h

… ou des fonctions /** * Swaps two objects of type T. * Swaps two objects of type T. * T should provide copy constructor * T should provide copy constructor * and operator= * and operator= */ */ template void swap( T& t1, T& t2 T& t1, T& t2); file.h template void swap( T& t1, T& t2 T& t1, T& t2 ) { T tmp(t1); T tmp(t1); t1 = t2; t1 = t2; t2 = tmp; t2 = tmp;} file.h

Les templates Le code template nest compilé que lors de linstanciation. On peut utiliser typename (ANSI), class ou int comme arguments templates. On peut imposer des fonctions aux arguments templates.

Exemple template class List { //… //…};/** * Sorts a List of objects of type T. * Sorts a List of objects of type T. * T must provide operators < * T must provide operators < */ */ template class ListSorter { public : ListSorter( List & list ); ListSorter( List & list ); void sort(); void sort(); private : List & list_; List & list_;}; file.h

Programmation Générique Idée: Remplacer les fonctions virtuelles par des spécifications darguments templates…

Conclusions Quelques heures pour apprendre le C++ … Cest peu !!! –Gestion des exceptions –Amitié entre objets –Standard Template Library –ANSI C++ –Pratique

Références Brokken et Kubat, C++ Annotations, Stroustrup, Le langage C++ (3 e ed.), Addisson Wesley, Gamma et al., Design Patterns, Addisson Wesley, Meyers, Effective C++, Addisson Wesley. Gautier et al., Cours de Programmation par objets, Masson.