Programmation orientée objet : le cas de C++

Ecole Doctorale MathIf Programmation orientée objet : le cas de C++ Violaine Louvet 1 1 ICJ - CNRS Année 2009-2010

Objectifs de ce cours Connaître et comprendre les concepts de la programmation orientée objet. Connaître les patrons de conception les plus importants. Assimiler les notions principales du C++. Comprendre l utilisation du C++ en calcul scientifique.

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Langages Classement Langage Popularité 1 Java 17.348% 2 C 16.602% 3 PHP 10.001% 4 C++ 9.447% 5 (Visual) Basic 7.051% 6 C# 5.015% 7 Python 4.314% 8 Perl 3.600% 29 Fortran 0.377% Source : http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

Langages Classement Langage Popularité 1 Java 17.348% 2 C 16.602% 3 PHP 10.001% 4 C++ 9.447% 5 (Visual) Basic 7.051% 6 C# 5.015% 7 Python 4.314% 8 Perl 3.600% 29 Fortran / Fortran 0.377% Source : http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html Langage objet Langages procéduraux

Les différents types de langages Langage compilé : traduit en instructions lisibles par la machine une fois pour toutes. Fortran, C, C++... Langage semi-interprété : il existe un compilateur traduisant le programme non pas en «langage-machine» mais en un code intermédiaire assez analogue à de l assembleur (pseudo-code, p-code, Byte Code). Java, Python... Langage interprété : converti en instructions exécutables par la machine au moment de son exécution. PHP, Perl... Typage explicite ou implicite : explicite quand les types apparaissent explicitement dans le code source du programme ; implicite : déterminé par le compilateur ou l interprète. Typage fort ou faible : Plus un typage est fort, plus les règles du langage sont strictes et interdisent dès la compilation les manipulations entre données de types différents. Typage statique ou dynamique : statique quand la vérification des types se fait dès la phase de compilation, et dynamique lorsque celle-ci est faite durant l exécution.

Les différentes méthodes de programmation On peut identifier 5 paradigmes de programmation : Programmation impérative (Pascal, Fortran, C++/C,...) : décrit les opérations en termes d états du programme et de séquences d instructions exécutées par l ordinateur pour modifier l état du programme. Programmation fonctionnelle (Lisp, ML, Scheme,...) : considère le calcul en tant qu évaluation de fonctions mathématiques et rejette le changement d état et la mutation des données. Programmation objet (Smalltalk, Eiffel, Java,...) : consiste en la définition et l assemblage de briques logicielles appelées objets. Programmation logique (Prolog,...) : définit des règles de logique mathématique au lieu de fournir une succession d instructions. Programmation parallèle (MPI,...) : programmation par échange de messages. un langage peut être fondé sur plusieurs de ces paradigmes.

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Du fonctionnel à l objet Approche Fonctionnelle L important c est les traitements diviser pour règner réutilisation difficile, évolution difficile... Approche objet L important c est les objets monde réel modèle du monde réutilisation et évolution simplifiée Principe de réification Matérialiser un concept par un objet. Réifier un concept permet de le manipuler concrètement.

Conception orientée objet Utiliser un langage orienté objet ne veut pas dire que l on fait de la programmation par objet correcte. Conception orientée objet Calquer le découpage de la représentation informatique sur les entités physiques mises en jeu dans les processus réels que l on cherche à modéliser ou à automatiser Privilégier une approche architecturale pour implémenter des solutions à des problèmes plutôt qu une approche fonctionnelle visant à résoudre un problème posé Stabilité de la modélisation par rapport aux entités du monde réel Construction itérative facilitée par le couplage faible entre composants Possibilités de réutiliser des éléments d un développement à un autre...

Langage de modélisation : UML Langage couramment employé pour décrire la structure d une application dans le monde objet. UML = Unified Modeling Langage. Langage graphique permettant d exprimer différents aspects structurant l application. Chaque type de diagramme permet de modéliser un point de vue particulier de nos objets, des besoins utilisateur, des contraintes du système, etc. : diagrammes de classes, diagrammes de cas d utilisation, diagrammes de séquences...

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

5 concepts clés abstraction encapsulation modularité réutilisation polymorphisme

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Objets Un objet représente un objet ou un concept de la vie réelle. Un objet associe données et traitements en ne laissant visible que l interface de l objet, c est à dire les traitements que l on peut faire dessus. Chaque objet : a un état caractérisé par la valeur de ses attributs ; propose des services sous la forme de méthodes. Les attributs et les méthodes d un objet sont ses membres.

Classes La classe décrit le domaine de définition d un ensemble d objets : c est un modèle qui définit les données et les traitements communs à une collection d objets similaires. Chaque objet appartient à une classe. Du point de vue typage, une classe doit être vue comme le type des objets qui seront créés à partir d elle. Tout objet est instance d une classe.

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Encapsulation Encapsulation = masquage de l information L objet fournit une relation d encapsulation qui assure à la fois une cohésion interne très forte et un faible couplage avec l extérieur. Facilite la modularité, la réutilisation de code, et la maintenance. La représentation interne peut être modifiée sans affecter l interface : occultation des détails de réalisation. visibilité publique : visible de partout. visibilité privée : visible que pour les méthodes de la classe. visibilité protégée : visible à l intérieur de la classe et dans les classes dérivées.

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Héritage L héritage correspond à une extension de l objet (spécialisation) L héritage peut être simple ou multiple. La classe dérivée contient les attributs et les méthodes de sa classe de base. On peut définir de nouveaux attributs et de nouvelles méthodes pour la classe dérivée, qui viennent s ajouter à ceux et celles héritées.

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Polymorphisme Capacité d un objet à modifier son comportement propre et celui de ses descendants au cours de l exécution. Polymorphisme ad hoc (ou surcharge). Polymorphisme paramétrique (généricité ou template). Polymorphisme d héritage.

Polymorphisme ad hoc Définir des méthodes de même nom dans des classes indépendantes. Permet d avoir des fonctions de même nom, avec des fonctionnalités similaires, dans des classes sans aucun rapport entre elles. La classe Matrice et la classe Vecteur peuvent avoir chacune une fonction afficher. Surcharge d opérateur : définir des opérateurs dont l utilisation sera différente selon le type des paramètres qui leur sont passés. Surcharge de l opérateur + qui réalisera des actions différentes selon qu il s agit d une opération entre deux Vecteurs ou entre deux Matrices.

Polymorphisme paramétrique, template Possibilité de définir plusieurs fonctions de même nom mais possédant des paramètres différents (en nombre et/ou en type). On appelle signature le nombre et le type (statique) des arguments d une fonction. C est donc la signature d une méthode qui détermine laquelle sera appelée. Ces paramètres peuvent aussi être le type d autres paramètres (template). La fonction Matrice add(matrice,double) va additionner le double à tous les termes de la matrice. La fonction Matrice add(matrice,matrice) va ajouter deux matrices. La fonction template<t> Matrice add(matrice,t) va ajouter un objet de type T à une matrice.

Polymorphisme d héritage Chaque sous classe peut modifier localement le comportement de ses opérations pour considérer le particularisme de son niveau d abstraction.

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Design Patterns = patrons de conception Description d une solution classique à un problème récurrent suivant le paradigme objet. Indépendants du langage de programmation. Description de procédés de conception généraux. Capitalisation de l expérience appliquée à la conception logicielle. Guide/catalogue de solutions Trois familles de patrons de conceptions selon leur utilisation : de construction : définissent comment faire l instanciation et la configuration des classes et des objets. structuraux : définissent comment organiser les classes d un programme dans une structure plus large (séparant l interface de l implémentation). comportementaux : définissent comment organiser les objets pour que ceux-ci collaborent (distribution des responsabilités) et expliquent le fonctionnement des algorithmes impliqués.

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Singleton Patron de création restreindre l instanciation d une classe à un seul objet. Il est utilisé lorsque l on a besoin d exactement un objet pour coordonner des opérations dans un système. Exemple : Ne définir qu un seul domaine géométrique dans un code de calcul.

Fabrique Patron de création La fabrique a pour rôle l instanciation d objets divers dont le type n est pas prédéfini : les objets sont créés dynamiquement en fonction des paramètres passés à la fabrique. Exemple : pouvoir créer différents type de matrices.

Proxy Patron de structure Le proxy sert à gérer l accès à un objet, il agit comme un intermédiaire entre la classe utilisatrice et l objet. Exemple : Interfaçage de code fortran.

Adaptateur Patron de structure Convertir une interface existante afin de la rendre compatible avec une autre interface Exemple : Gèrer plusieurs type de sortie d un code avec utilisation de bibliothèques déjà existantes.

Itérateur Patron comportemental Un itérateur est un objet qui permet de parcourir tous les éléments contenus dans un autre objet, le plus souvent un conteneur (liste, arbre, etc.). Exemple : Pouvoir parcourir les éléments d une matrice creuse.

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Introduction Le langage C est un langage très efficace mais de bas niveau. Le langage C++, développé par Bjarne Stroustrup, permet la programmation sous de multiples paradigmes et notamment l objet. C++ (opérateur d incrémentation en C) est un niveau au-dessus du C. Le langage C++ est normalisé par l ISO. La dernière normalisation date de 2003. On peut considérer que C++ «est du C» avec un ajout de fonctionnalités. Remarque importante : certains programmes syntaxiquement corrects en C ne le sont pas en C++.

Fichiers sources Fichiers d en-tête : «headers» : d extension.h ou.hpp (mais la plupart des entêtes systèmes du C++ standard n ont plus d extension du tout). contiennent généralement les prototypes de différentes fonctions, structures et classes. Fichiers sources : Extension.cpp,.cxx,.cc, parfois.c. Contiennent la définition (l implémentation) des différentes fonctions et méthodes définies dans les fichiers d en-tête. Leur compilation produit des fichiers objets (extension *.o). Ils utilisent les fichiers d en-tête : #include " nomdefichier. h " #include <monfichier >

Pointeurs Tout objet manipulé par l ordinateur est stocké dans sa mémoire à un emplacement appelé adresse. Une adresse est une valeur qui peut être stocké dans une variable appelé pointeur. Le pointeur a un type construit à partir du type de l objet pointé : i n t ip ; / / i p est un pointeur d e n t i e r Déréférencement : accès à l objet pointé. cout << &ip ; / / e c r i t sur la sortie standard la valeur / / contenu dans l a case pointee par l e p o i n t e u r i p Indirection : récupérer l adresse d un objet. i n t i = 0; i n t ip2 = & i ; / / ip2 pointe sur l adresse de i

Références Une référence peut être vue comme un alias d une variable. Une référence doit obligatoirement être initialisée lors de sa déclaration. i n t i ; i n t & r = i ; / / r est une reference sur i r = j ; / / copie l a valeur de j dans i ( et dans r ) Le compilateur la remplace par le nom de la variable actuellement assignée dans le code après avoir déroulé les traitements mais avant de traduire ce code en binaire. Une variable et ses différentes références ont la même adresse.

Références Principalement utilisées pour passer des paramètres aux fonctions (ou référencer des résultats de retour de fonctions). : Passage par valeur : copie dans une variable locale. void t e s t ( int i ) { i = 2; return ; } i n t main ( void ) { } i n t i = 3; t e s t ( i ) ; cout << i << endl ; / /?? return 0; Passage par référence : pas de copie. void t e s t ( int& i ) { i = 2; return ; } i n t main ( void ) { } i n t i = 3; t e s t ( i ) ; cout << i << endl ; / /?? return 0;

Références Principalement utilisées pour passer des paramètres aux fonctions (ou référencer des résultats de retour de fonctions). : Passage par valeur : copie dans une variable locale. void t e s t ( int i ) { i = 2; return ; } i n t main ( void ) { } i n t i = 3; t e s t ( i ) ; cout << i << endl ; / / a f f i c h e 3 return 0; Passage par référence : pas de copie. void t e s t ( int& i ) { i = 2; return ; } i n t main ( void ) { } i n t i = 3; t e s t ( i ) ; cout << i << endl ; / / a f f i c h e 2 return 0;

Entrées/Sorties En-tête iostream de la bibliothèque standard C++ : classes extrêmement puissantes permettant de manipuler les flux d entrée / sortie. Surcharge de l opérateur << (opérateur d insertion) : écritures sur un flux de données Surcharge de l opérateur >> (opérateur d extraction) : lecture d une nouvelle donnée dans le flux d entrée. Trois instances particulières des classes d entrée / sortie : cin, instance de la classe istream : entrée standard. cout, instance de la classe ostream : sortie standard. cerr : écriture des messages d erreur des programmes. Il est possible d effectuer plusieurs entrées ou plusieurs sorties successivement sur un même flux. endl : signale une fin de ligne et effectue un saut de ligne lorsqu il est employé sur un flux de sortie.

Exemple d Entrées/Sorties # include < iostream > using namespace std ; i n t main ( void ) { i n t i ; / / L i t un e n t i e r depuis l entree standard : c i n >> i ; / / A f f i c h e cet e n t i e r et l e s u i v a n t : cout << i << " " << i +1 << endl ; return 0; }

Allocation dynamique de mémoire Les pointeurs sont utilisés pour créer un nombre quelconque de variables, ou des variables de taille quelconque, en cours d exécution du programme. En C : utilisatin des fonctions malloc(taille) et free(pointeur). En C++ : opérateurs spécifiques new, delete. Si les objets créés sont des instances de classes, le constructeur de ces classes sera automatiquement appelé lors de leur initialisation (voir plus loin). int i = new int ; / / Equivalent a ( i n t ) malloc ( s i z e o f ( i n t ) ). delete i ; / / Equivalent a f r e e ( p i ) ; i n t Tableau=new i n t [ 1 0 0 0 0 ] ; / / A l l o c a t i o n d un tableau de 1000 e n t i e r s delete [ ] Tableau ; / / D e s t r u c t i o n du tableau

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Classes Dans le fichier en-tête Vecteur.h : class Vecteur { public : void I n i t i a l i s e r ( double ) ; private : double Tab ; i n t Size ; } ; Dans le fichier source Vecteur.cc (à l aide de l opérateur de résolution de portée) : #include " Vecteur. h " void Vecteur : : I n i t i a l i s e r ( double d ) { for ( i n t i = 0 ; i < Size ; i ++) Tab [ i ] = d ; }

Constructeurs Fonction membre particulière de la classe. Il peut y aoir plusieurs constructeurs avec différents paramètres. Toujours appelée lors de la création d une nouvelle instance d une classe. Constructeur par défaut : c est le constructeur sans argument. Si aucun constructeur n est présent explicitement dans la classe, il est généré par le compilateur. Constructeur par copie : c est un constructeur à un argument dont le type est celui de la classe. class Vecteur { public : / / Constructeur par defaut Vecteur ( ) ; Vecteur ( int ) ; / / Constructeur / / Constructeur par copie Vecteur ( const Vecteur & ) ;... #include " Vecteur. h " Vecteur : : Vecteur ( ) { } Vecteur : : Vecteur ( i n t n ) : Size ( n ) { Tab = new double [ n ] ; } Vecteur : : Vecteur ( Vecteur& v ) { Size = v. getsize ( ) ; Tab = new double [ Size ] ; }

Destructeur Fonction membre particulière de la classe. S il n est pas explicitement présent dans la classe, il sera généré par le compilateur. Le destructeur est appelé lorsqu une instance d une classe est détruite. class Vecteur { public : ~Vecteur ( ) ;... #include " Vecteur. h " Vecteur : : ~ Vecteur ( ) { i f ( Tab!= NULL) delete [ ] Tab ; }...

Accesseurs class Vecteur { Fonctions membres qui ne modifient pas l état de l objet. Elles sont déclarées const. Le compilateur signale une erreur si une fonction de ce type cherche à modifier une variable membre. public : int getsize ( ) const ;... #include " Vecteur. h " i n t Vecteur : : getsize ( ) const { return this >Size ; }...

Déclaration et utilisation des objets # include < iostream > #include " Vecteur. h " using namespace std ; i n t main ( void ) { i n t n = 10; / / On cree un o b j e t Vecteur en appelant / / l e c o n s t r u c t e u r avec un argument e n t i e r Vecteur vect ( n ) ; / / On i n i t i a l i s e l e Vecteur a 0 vect. I n i t i a l i s e r ( 0. ) ; / / Affichage de l a t a i l l e : cout << " T a i l l e du vecteur : " << vect. getsize ( ) << endl ; return 0; }

Membres statiques Membres partagés par tous les objets de la classe. Non statiques : variables et méthodes d instances. Statiques : variables et méthodes de classe. Il n en existe qu un seul exemplaire par classe. Il faut créer et initialiser la donnée membre statique (ce qui n est pas fait par le constructeur). #include " Vecteur. h " i n t Vecteur : : Nvect = 0; class Vecteur { private : s t a t i c i n t Nvect ;... Vecteur : : Vecteur ( ) { / / on incremente l a valeur dans / / chacun des c o n s t r u c t e u r s NVect ++; } Vecteur : : ~ Vecteur ( ) {... / / on decremente l a valeur Nvect ; }...

Amis Une fonction ou une classe amie a le droit d accéder à tous les membres de la classe (publics ou privés). Elle doit être déclarée ou définie dans la classe qui accorde le droit d accès. class Vecteur { public : friend void a f f i c h e r ( const Vecteur & ) ;... #include " Vecteur. h " #include <iostream > using namespace std ; void a f f i c h e r ( const Vecteur &v ) { for ( i n t i = 0 ; i < v. Size ; i ++) cout << i << " " << v. Tab [ i ] << end ; }...

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Surcharge des opérateurs Tous les opérateurs de C++ peuvent être surchargés sauf : «.», «.*», «: :», «?», «:», «sizeof». Fichier Vecteur.cc #include " Vecteur. h " Fichier Vecteur.h class Vecteur { public : double operator [ ] ( const i n t ) const ;... double Vecteur : : operator [ ] ( const i n t i ) const { return Tab [ i ] ; }... i n t main ( void ) {... for ( i n t i = 0 ; i < vect. getsize ( ) ; i ++) cout << vect [ i ] << endl ;... }...

Surcharge des opérateurs L exemple précédent ne permet pas de modifier un Vecteur à l aide de l opérateur crochet. Fichier Vecteur.cc #include " Vecteur. h " Fichier Vecteur.h class Vecteur { public : double& operator [ ] ( const i n t ) ;... double& Vecteur : : operator [ ] ( const i n t i ) { return Tab [ i ] ; }... i n t main ( void ) {... for ( i n t i = 0 ; i < vect. getsize ( ) ; i ++) vect [ i ] = 0.3 i ;... }...

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Héritage 3 types d héritage (public, protégé, privé) qui définissent les droits d accès aux membres de la classe de base. Le plus souvent : héritage public : les membres de la classe de base conservent leur accès (privé, protégé et public). Fichier Matrice.h class Matrice { public : void I n i t i a l i s e r ( double ) ; protected : double Tab ; private : i n t Size ; } ; Fichier MatricePleine.h #include Matrice. h class MatricePleine : public Matrice { } ;

Construction, destruction dans les liens d héritage L activation d un constructeur commence par les appels des constructeurs de chacune de ses classes de bases directes, dans l ordre de déclaration de ces classes de bases directes. Sont ensuite exécutées les instructions qui composent le corps du constructeur. L exécution d un destructeur commence par l exécution des instructions présentent dans le corps du destructeur. Puis appels des destructeurs des classes de base dans l ordre inverse des déclarations. Fichier MatricePleine.h Fichier Matrice.h class Matrice { public : Matrice ( int, i n t ) ; ~Matrice ( ) ; protected : i n t Size1, Size2 ; } ; #include Matrice. h class MatricePleine : public Matrice { public : MatricePleine ( int, int ) ; ~MatricePleine ( ) ; private : double Tab ; } ;

Construction, destruction dans les liens d héritage Fichier Matrice.cc Fichier MatricePleine.cc #include MatricePleine. h #include Matrice. h #include <iostream > using namespace std ; Matrice : : Matrice ( i n t n1, i n t n2 ) : Size1 ( n1 ), Size2 ( n2 ) { } Matrice : : ~ Matrice ( ) { cout << Destruction Matrice << endl ; } Fichier main.cc #include " MatricePleine. h " i n t main ( void ) { MatricePleine mat ( 5, 5 ) ; return ( 0 ) ; } MatricePleine : : MatricePleine ( i n t n1, i n t n2 ) : Matrice ( n1, n2 ) { Tab = new double [n2 ] ; for ( i n t i = 0 ; i < n2 ; i ++) Tab [ i ] = new double [ n1 ] ; } MatricePleine : : ~ MatricePleine ( ) { cout << Destruction MatricePleine << endl ; for ( i n t i = 0 ; i < n2 ; i ++) delete [ ] Tab [ i ] ; delete [ ] Tab ; } Sortie standard D e s t r u c t i o n MatricePleine D e s t r u c t i o n Matrice

Polymorphisme : redéfinition d une fonction membre Les membres publics d une classe de base peuvent être atteints à travers un objet de la classe dérivée. Fichier Matrice.h Fichier MatricePleine.h class Matrice {... public : void a f f i c h e r ( ) const ;... } ; Fichier Matrice.cc... void Matrice : : a f f i c h e r ( ) const { cout << " Affichage d une Matrice " << endl ; cout << " Dimensions : " << Size1 << " x " << Size2 << endl ; } Fichier main.cc... MatricePleine matp ( 5, 5 ) ; matp. a f f i c h e r ( ) ; Matrice mat ( 4, 4 ) ; mat. a f f i c h e r ( ) ;...... class MatricePleine : public Matrice {... public : void a f f i c h e r ( ) const ;... } ; Fichier MatricePleine.cc... void MatricePleine : : a f f i c h e r ( ) const { cout << " Affichage d une M atricepleine " << endl ; Matrice : : a f f i c h e r ( ) ; } Sortie standard Affichage d une MatricePleine Affichage d une Matrice Dimensions : 5x5 Affichage d une Matrice Dimensions : 4x4

Polymorphisme : fonction membre virtuelle Une fonction virtuelle permet aux classes dérivées de remplacer l implémentation fournie par la classe de base. Le compilateur s assure que la méthode remplacée est bien appelée quand l objet en question est bien du type de la classe dérivée, même si l objet est accédé par un pointeur de base plutôt qu un pointeur dérivé. Les destructeurs peuvent être déclarés virtuels. Fichier Matrice.h... public : v i r t u a l ~Matrice ( ) ; v i r t u a l void p r i n t ( ) const ;... Fichier MatricePleine.h... public : void p r i n t ( ) const ;...

Polymorphisme : fonction membre virtuelle Fichier Matrice.cc Fichier MatricePleine.cc... void Matrice : : p r i n t ( ) const { cout << " Print d une Matrice " << endl ; }... void MatricePleine : : p r i n t ( ) const { cout << " Print d une MatricePleine " << endl ; } Fichier main.cc... Matrice pmatp ; pmatp = new MatricePleine ( 3, 3 ) ; pmatp >p r i n t ( ) ; Matrice pmat ; pmat = new Matrice ( 2, 2 ) ; pmat >p r i n t ( ) ;... Sortie standard P r i n t d une MatricePleine r i n t d une Matrice

Classe abstraite Les fonctions virtuelles apparaissent en général dans des classes à des niveaux d abstraction élevés qui peuvent rendre leur implémentation non vraisemblable. Ces classes représentent des abstractions. Leurs méthodes doivent être dans ce cas des contraintes pour leurs classes dérivées : on les définit virtuelles pures. Une classe ayant une ou des méthodes virtuelles pures est abstraite. On ne peut pas les instancier.

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Templates Un template (modèle) définit une famille de fonctions ou de classes paramétrée par une liste d identificateurs qui représentent des valeurs et des types. Les paramètres des templates doivent être connus à la compilation. Les fichiers d en-tête doivent contenir non seulement la déclaration, mais également la définition complète des template. Les classes ou fonction template sont (re)compilée pour chaque type d instance présent dans le programme.

Templates de fonction Fichier main.cc template <class T> T Min ( T x, T y ) { return x<y? x : y ; } i n t main ( void ) { i n t i = 3; i n t j = 6; cout << Min de i et j << Min<int >( i, j ) << endl ; return ( 0 ) ; } Sortie standard Min de i et j 3

Templates de classes Fichier Vecteur.h #include <iostream > using namespace std ; template <class T> class Vecteur { public : Vecteur ( i n t ) ; ~Vecteur ( ) ; void I n i t i a l i s e r ( T ) ; void p r i n t ( ) ; private : i n t Size ; T Tab ; } ; template <class T> Vecteur <T>:: Vecteur ( i n t n ) : Size ( n ) { Tab = new T [ Size ] ; } template <class T> void Vecteur <T > : : I n i t i a l i s e r ( T dat ) { for ( i n t i = 0 ; i < Size ; i ++) Tab [ i ] = dat ; } template <class T> void Vecteur <T > : : p r i n t ( ) { for ( i n t i = 0 ; i < Size ; i ++) cout << i << " " << Tab [ i ] << endl ; } template <class T> Vecteur <T>::~ Vecteur ( ) { delete [ ] Tab ; }

Templates de classes Fichiermain.c #include " Vecteur. h " using namespace std ; i n t main ( void ) { Vecteur <int > t i n t ( 3 ) ; t i n t. I n i t i a l i s e r ( 4 ) ; t i n t. p r i n t ( ) ; Vecteur <double> t d b l ( 4 ) ; t d b l. I n i t i a l i s e r ( 6. 5 ) ; t d b l. p r i n t ( ) ; Sortie standard 0 4 1 4 2 4 0 6.5 1 6.5 2 6.5 3 6.5 } return ( 0 ) ;

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Exceptions : principes Interruption de l exécution du programme à la suite d un événement particulier. Le C++ supporte les exceptions logicielles : permet de gérer les erreurs qui surviennent lors de l exécution des programmes. Lorsqu une telle erreur survient : lancement d une exception. L exécution normale du programme s arrête, le contrôle est passé à un gestionnaire d exception. Le gestionnaire d exception gttrape l exception.

Lancer une exception Lancer une exception = retourner une erreur sous la forme d une valeur (message, code, objet exception) dont le type peut être quelconque (int, char*, classe d exceptions,...). Instruction «throw expression», la valeur de «expression» est supposée décrire l exception. Fichier Vecteur.h... template <class T> class Vecteur {... public : T operator [ ] ( const i n t ) const throw ( i n t ) ; T& operator [ ] ( const i n t ) throw ( i n t ) ;... } ;... template <class T> T Vecteur <T>:: operator [ ] ( const i n t i ) const throw ( i n t ) { i f ( i >= Size ) throw 0; return Tab [ i ] ; } template <class T> T& Vecteur <T>:: operator [ ] ( const i n t i ) throw ( i n t ) { i f ( i >= Size ) throw 0; return Tab [ i ] ; }

Attraper une exception Pour attraper une exception, il faut qu un bloc encadre l instruction directement, ou indirectement, dans la fonction même ou dans la fonction appelante, ou à un niveau supérieur. Dans le cas contraire, le système récupère l exception et met fin au programme. Instruction «try{...} catch {...}». Fichiermain.c #include " Vecteur. h " using namespace std ; i n t main ( void ) { Vecteur <double> t d b l ( 4 ) ; t d b l. I n i t i a l i s e r ( 6. 5 ) ; t r y { cout << t d b l [ 5 ] << endl ; } catch ( i n t i e x ) { i f ( i e x == 0) c e r r << Exception : acces hors l i m i t e << endl ; } return ( 0 ) ; } Sortie standard Exception : acces hors l i m i t e

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Introduction L optimisation de code fait intervenir des données assez contradictoires : rester «haut niveau» et être le plus efficace possible. Une utilisation «naïve» des facilités du C++ peut donner un code peu performant. De nombreuses bibliothèques optimisés sont des compléments naturels du langage (STL, Boost, Blitz++...). Principaux éléments du C++ scientifique Réduction des objets temporaires polymorphisme statique (template) Traits Expression templates Metaprogrammation

Objets temporaires Les objets temporaires sont créés lorsque le langage a besoin d un objet et que celui n est pas nommé Chaque fois qu une fonction doit retourner une valeur (au sens C++) car l objet (la valeur) de retour d une fonction n est pas nommé. Exemple : surcharge de l opérateur + Vecteur u, v,w; w = u+v ; Appel du constructeur de copie qui recopiera la somme u + v dans un objet temporaire t, local à la fonction membre operator + de la classe Vecteur. Cet objet temporaire t est ensuite retourné par valeur, d où un deuxième appel au constructeur de copie. Inacceptable lorsque la taille des objets en question est grande, ce qui est le cas en calcul scientifique.

Polymorphisme dynamique Le polymorphisme dynamique, basé sur les fonctions virtuelles a un coût : l appel d une fonction virtuelle est une décision prise pendant l exécution (et consiste en général en des indirections). L appel d une fonction virtuelle ne peut bénéficier du mécanisme «inline» puisque le type exact de l objet n est pas connu au moment de la compilation. Le coût d une fonction virtuelle devient prohibitif quand : le code qu elle contient est petit elle est appelée souvent (par exemple dans une boucle).

Polymorphisme dynamique Exemple classique class Matrice { public : v i r t u a l double operator ( ) ( i n t i, i n t j ) = 0; } ; class SymmetricMatrice { public : v i r t u a l double operator ( ) ( i n t i, i n t j ) ; } ; L utilisation de l opérateur «()» dans une boucle pénalisera fortement les performances. Solution : remplacer le polymorphisme dynamique (fonction virtuelle) avec du polymorphisme statique (template).

Metaprogramming La meta-programmation consiste à reporter le maximum de décisions dans la phase de compilation. Inconvénients : Temps de compilation nettement accru. La règle de base est que tout doit toujours rester au maximum connu du compilateur. Fonctions = classes/structures / / Fonction qui r e n v o i t son parametre i n t I d e n t i t e ( i n t N) { return N; } unsigned i n t x = I d e n t i t e ( 5 ) ; / / x ne sera connu que lorsque l e programme sera execute / / La meme en meta programme template < i n t N> struct I d e n t i t e { enum { Value = N ; } } ; unsigned i n t x = Identite <5 >:: Value ; / / l a valeur de x est connue de notre compilateur Utiliser l in-lining : l appel à une telle fonction est remplacé par le code correspondant.

Metaprogramming Conditions : if/else = structure/classe template <bool Condition > struct Test { } ; template<> struct Test <true > { s t a t i c void Do ( ) { DoSomething ( ) ; } } ; template<> struct Test <false > { s t a t i c void Do ( ) { DoSomethingElse ( ) ; } } ; / / Code h a b i t u e l i f ( Condition ) DoSomething ( ) ; else DoSomethingElse ( ) ; / / Avec l a s t r u c t u r e Test Test <Condition > : : Do ( ) ; Boucles : récursion (pour boucler) et spécialisation (pour s arrêter) template < i n t Begin, i n t End> struct Boucle { s t a t i c void Do ( ) { DoSomething ( ) ; Boucle <Begin + 1, End > : : Do ( ) ; } } ; template < i n t N> struct Boucle <N, N> { s t a t i c void Do ( ) { } } ; / / Methode h a b i t u e l l e for ( i n t i = 5; i < 15; ++ i ) DoSomething ( ) ; / / Avec l a s t r u c t u r e Boucle Boucle <5, 15 >::Do ( ) ;

Expression templates technique permettant de contourner les problèmes des objets temporaires dûs à l évaluation par paire des opérations en C++. L idée est de bâtir statiquement, i.e. pendant la compilation, l arbre d une expression. différer l évaluation des calculs : Au lieu de calculer des résultats intermédiaires, les surcharges d opérateurs vont construire l arbre syntaxique de l expression, à l aide de classes templates. L opérateur = va ensuite parcourir cet arbre syntaxique et effectuer en un seul coup le calcul. Vecteur V1, V2, V3, V4 ; V4 = (V1 / 2.5) (V2 + V3 ) 5;

Traits Abstraction des types de données. Les traits sont des petits objets qui fournissent des informations à propos d un autre objet (ou algorithme) pour déterminer la marche à suivre ou des détails d implémentation. Une classe de trait, généralement template, définit des caractéristiques ou des fonctions associées à un type donné afin de généraliser leur utilisation. Classe de traits qui fournit une valeur nulle appropriée pour chaque type template <typename T> struct ValeurNulle ; typename <> struct ValeurNulle <int > { static int Zero ( ) { return 0 ; } } ; typename <> struct ValeurNulle <std : : string > { s t a t i c std : : string Zero ( ) { return " " ; } } ; typename <> struct ValeurNulle <MaClasse> { s t a t i c MaClasse Zero ( ) { return MaClasse ( 1 ) ; } } ;... template <typename T> void Fonction ( T Valeur ) { T Ret = ValeurNulle <T > : : Zero ( ) ;... }

Sommaire 1 Introduction Langages et paradigmes de programmation Conception orientée objet 2 Concepts fondamentaux Objets, classes Encapsulation Héritage Polymorphisme 3 Design Patterns Présentation Quelques exemples 4 Le cas de C++ Elements préalables Classes Surcharge des opérateurs Héritage Templates Exceptions 5 C++ et calcul scientifique 6 Références

Références «Design Patterns», Gamma, Helm, Johnson, Vlissides. Patrons de conception : http://fr.wikibooks.org/ wiki/patrons_de_conception «Le langage C++», Bjarne Stroustrup, 4e Ed, Addison Wesley. Norme ISO C++ : http://www.open-std.org/jtc1/sc22/wg21/. FAQ C++ : http://cpp.developpez.com/faq/cpp/. Exemple simplifié d utilisation des traits : http://www.cppfrance.com/codes/ UTILISATION-TECHNIQUE-TRAITS_37173.aspx. Meta-programmation : http://loulou.developpez. com/tutoriels/cpp/metaprog/. «Vers une nouvelle approche du calcul scientifique en C++», Gabriel Dos Reis, Tech. Report RR-3362, INRIA. «Techniques for Scientific C++», Todd Veldhuizen, Indiana University Computer Science Tech. Report, 2000.