LO43 : Bases fondamentales de la programmation orientée objet

Transcription

1 LO43 : Bases fondamentales de la programmation orientée objet Langage C++ Franck GECHTER franck.gechter@utbm.fr

2 Template La Conception Orientée Objet, Liaison Statique et Liaison Dynamique

3 Template La Conception Orientée Objet (C.O.O.)

4 Template La Conception Orientée Objet (C.O.O.) Introduction : Qu est ce qu un programme? Reflexions sur la vie d un logiciel Qu est ce qu un bon programme? Modularité et Réutilisabilité Principes de la Conception Orientée Objet

5 Template Introduction

6 Template Qu est ce qu un programme? Un programme peut se résumer par l équation suivante Programme = Algorithmes + Structures de Données Il y a donc deux choix de conception soit en s appuyant sur les traitements soit en s appuyant sur les données. L approche par traitement est l approche traditionnelle (décomposition du problème en tâches simples tout en utilisant les fonctions existantes

7 Template Inconvénients de la conception par traitements Les modules sont, en général, ad hoc adaptés au problème de départ Les traitements ne prennent pas en considération les structures de données sous-jacentes Il n est pas toujours évidant d identifier les traitements Les traitements sont généralement beaucoup moins stables que les données

8 Template Inconvénients de la conception par traitements Il y a quand même quelques avantages à ces méthodes : approche intuitive, facilement applicable pour des applications de taille raisonnable.

9 Template Reflexions sur la vie d un logiciel trouve ses fondements dans une reflexion menée autour de la vie du logiciel. Le développement de logiciels de plus en plus importants Utilisation de règles Qualité de réalisation Réalisation plusieurs phases Le développement n est que la première partie 70% correspond à la phase de maintenance.

10 Template Qu est ce qu un bon programme? La correction ou validité : le logiciel effectue les tâches pour lesquelles il a été conçu. L extensibilité : intégration de nouvelles spécifications. La réutilisabilité : réutilisation globale ou partielle - il faut prendre soin à l organisation du logiciel. La robustesse : capacité de fonctionnement même dans des conditions anormales

11 Template La Modularité Les contraintes énoncées précédemment obligent à s écarter d une vision monolithique de la programmation programmation sous forme de modules Deux méthodes de conception modulaire : Approche descendante : décomposition d un problème donné en sous-problèmes de façon récursive jusqu à des sous problèmes triviaux Approche ascendante : composition de briques logicielles simples (bibliothèques) Les deux méthodes ne sont pas mutuellement exclusives L approche descendante ne favorise pas forcément la réutilisabilité.

12 Template La Modularité : Critères de qualité Compréhensibilité modulaire : modules clairs, organisés de manière cohérente et communiquant avec un nombre limité de modules Continuité modulaire : une modification d un module modification d un petit nombre de modules sans implication pour les relations inter-modules. Protection modulaire : toute action sur un module doit être confinée à ce module (éventuellement nombre restreint de modules)

13 Template La Modularité : Principes Interface limitée : Restreindre les actions possibles pour un module Communications limitées : Limitation des communications de façon quantitatives Interface explicite Masquage de l information : Les informations contenus dans un module doivent être privées à l exception des actions ou des informations publiques Le langage de programmation doit s adapter à la spécification du module

14 Template La Réutilisabilité Ce n est pas un concept nouveau (bibliothèques, structure de données élémentaires,...) Principes : Un module doit pouvoir utiliser plusieurs types différents d informations Un module doit pouvoir s adapter aux différentes structures de données (recherche dans une liste idem recherche dans un tableau) Un module doit offrir des opérations sans pour autant en montrer leur implémentation Factorisation des opérations d un groupe de module au sein d un même module

15 Template Des techniques nouvelles La Surcharge : des opérations associées à des modules différents peuvent avoir le même nom. La Généricité : Définition de modules paramètrés par le type qu ils manipulent.

16 Template La Conception par Objets : Principes

17 Template La conception par objets Il semble maintenant naturel d organiser la programmation autour des données manipulées: les objets. Les données étant plus stables que les traitements la conception est simplifiée L approche par données respecte un certain nombre de critères de qualité (modularité, réutilisabilité,...)

18 Template La conception par objets Voici une définition de la conception par objets donnée par B. Meyer ainsi qu un conseil fort utile: La conception par objet est la méthode qui conduit à des architectures logicielles fondées sur les OBJETS que tout système ou sous-sytème manipule Ne commencez pas par demander ce que fait le système, demandez À QUOI il le fait!

19 Template Détermination des Objets Les objets vont couvrir tout type d entités. Ils sont assez similaires aux structures utilisées en Pascal ou en C mais sont dotés de propriétés supplémentaires. Pour décrire un objet dont on va s interesser, on utilise une Classe. constituent les modèles dont seront issus les objets, que l on appellera également instance de classe

20 Template Détermination des Objets Une classe est constituée d une partie comportant des champs (ou attributs ou données) et d une partie constituée de fonctions (ou méthodes) s appliquant sur les champs qui décrit les services disponibles pour l objet.

21 Template

22 Template Le langage C++ est un langage très complexe et complet. Il n est pas possible d en faire un tour complet au cours de cette UV: se reporter aux ouvrages donnés dans la bibliographie!! pratiquer chez soi!! Il peut être vu comme une extension du langage C (Un programme C valide est un programme C++ valide)

23 Template Historique du C++ Conçu dans les laboratoires AT&T Bell (par Bjarn Stroustrup) Extension des fonctionnalités du C en intégrant les concepts liés à la programmation objet Création du langage C+ (C et fonctionnalités objets) 1983 Création du langage C++ (C+ et généricité, liaison dynamique,...) Jusqu en 1997 évolution du langage et établissement d une norme (Attention certains compilateurs ne respecte toujours pas l intégralité de la norme)

24 Template Les Modules Tout comme en C, un module C++ est généralement implanté par un fichier d interface et un fichier d implémentation..hh,.h ou.hpp, fichiers d interface contenant les services offerts par le module. (Rq: dans la norme finale les headers devront perdre leur extension).cc,.c ou.cpp, fichiers d implémentation C++

25 Template Les Types Primitifs et Commentaires Les types primitifs sont les mêmes qu en C (char, int, float, double, void) auxquels on a ajoutés un type supplémentaire bool. Une variable de type bool peut prendre deux valeurs true ou false. Les commentaires peuvent se faire comme en C (/*... */) ou en utilisant le sigle de commentaires court // tenant sur une ligne.

26 Template Les Fonctions et Les Définitions de Variables Le langage C++ est fortement typé Possibilité de définir des valeurs par défaut pour les paramètres des fonctions (Attention à l ordre) Possibilité de définir des fonctions inline (à chaque appel la fonction est remplacée par le code source correspondant) On peut définir les variables à la volée (Attention il est FORTEMENT conseillé de continuer à les déclarer toutes en début de bloc)

27 Template Les Références L introduction de la notion de référence permet la mise en place d un mécanisme d alias sur les variables. La notion de pointeur du C permettait d accèder au contenu d une variable. Une référence est un nouveau nom donné à une variable existante. Une référence est également représentée sous la forme d une adresse (pointeur). Une référence s utilise comme une variable. Les opération sur les références sont effectuées sur les objets référenceés

28 Template Les Références Définition d une référence : Type &nomref = variableareferencer; int main() { int val = 10; int i; int *pval = &val; //Pointeur sur val int &refval = val; //Référence sur val int &refautre; // Erreur!!!! *pval = 12; i = refval; // i vaut 12, valeur de val }

29 Template Les Références Contrairement aux pointeurs, les références ne peuvent pas être vides Elles sont toujours initialisées lors de la déclaration On préférera les utiliser lorsqu on ne veut pas de valeur inconsistante (NULL)

30 Template Les Références : Passage de paramètres et valeur de retour En C, le passage des paramètre et valeurs de retour se fait par valeur. Pour simuler un passage par adresse on utilise alors les pointeurs. En C++ on peut utiliser les Références pour effectuer ce passage par adresse..... et laisser le compilateur choisir les bonnes instructions Le choix du mode de transmission se fait lors de la déclaration de la fonction

31 Template Les Références : Passage de paramètres et valeur de retour La transmission d arguments par référence simplifie l écriture de la fonction. Ceci induit des effets de bords que l on peut éviter avec le mot const. On peut utiliser ce mécanisme pour la valeur de retour d une fonction (intérêts lors de la surcharge d opérateurs)

32 Template Les Références : SWAP Exemple : Ecrivez la fonction Swap de deux entiers avec les pointeurs puis les références.

33 Template Les Références : SWAP void swapc(int *i, int *j) { int tmp = *i; *i = *j; *j=tmp;} void swapcpp(int &i, int &j) { int tmp = i; i = j; j = tmp; }

34 Template Les Références : SWAP int main() { int m =1, n = 2; swapc(&m,&n); swapcpp(m,n); }

35 Template Allocation Dynamique de mémoire Allocation dynamique grace aux opérateurs new et delete (ne plus utiliser malloc et free!!!!!!!!!) Il n est plus nécessaire d utiliser sizeof Le principe d utilisation est le même Pour les tableaux les opérateurs new et delete sont remplacés par new[] et delete[]

36 Template Allocation Dynamique : Exemple main() { int *pi = new int; int *tab = new int[10]; if ((pi!= NULL) && (tab!=null) {... delete pi; delete [] tab; } }

37 Template La Surcharge

38 Template La Surcharge La surcharge est l une des nouvelles fonctionnalités du C++ (réutilisabilité) Elle permet d attribuer le même nom à plusieurs opérateurs ou fonctions. L ambiguité est levée grâce au contexte (nombre et/ou type des paramètres) Une définition séparée est nécessaire pour chacun des profiles

39 Template La Surcharge : Exemple... int max(int a, int b); int max(int *tab, int taille); int max(int a, int b, int c);...

40 Template Les Entrées-Sorties

41 Template Les Entrées-Sorties Les entrées-sorties on été remaniées pour profiter de la surcharge. Pour pouvoir les utiliser il faut inclure l en-tête <iostream> il existe trois flots : cin : entrée standard (clavier par défaut) cout : sortie standard (écran par défaut) cerr : sortie message d erreur (écran par défaut) et permettent de faire les écritures et les lectures Ils sont surchargés pour permettre l utilisation de tous les types primitifs

42 Template Les Entrées-Sorties Avantages C++ par rapport au C La vitesse d execution est plus rapide (traduction effectuée au moment de la compilation). Il n y a plus de problèmes de type. Les instructions générées sont plus réduites. Il est possible de surcharger les opérateurs et pour manipuler d autres types.

43 Template

44 Template Une classe permet de définir (interface et implémentation) un objet en terme de structure de données et de fonctionnalités. On trouve à l interieur d une Classe C++ : Les attributs (variables définies dans la classe) Les méthodes (services offerts par la classe) Pour déclarer une classe il faut utiliser le mot clé class. Les attributs et méthodes sont ensuite définis comme les champs dans une structure C

45 Template Publique, Protégé ou Privé Les structures en C ne permettent que de réunir des variables, en C++ une classe y ajoute des fonctions. Une classe C++ peut comporter plusieurs sections public, protected ou private qui permettent de modifier le niveau de masquage des informations. public : attributs et/ou méthodes accessibles par n importe quel client de la classe. protected ou private : attributs et/ou méthodes inaccessibles aux clients extérieurs de la classe. (On verra la différence entre ces deux notions un peu plus tard)

46 Template Publique, Protégé ou Privé et Encapsulation Par convention les attributs de la classes sont protected ou private. On les déclare dans une section autre que public. Conséquence : les attributs ne sont plus directement accessibles Il faut des méthodes d accès publiques. C est ce qu on appelle l encapsulation.

47 Template Utilisation Une classe définit un type qui peut être utilisé comme tout autre type disponible L accès aux champs (méthodes et attributs) se fait de façon pointée (.) (objet ou référence sur objet) La notation flèchée (->)est utilisée lorsque l on dispose d un pointeur sur un objet.

48 Template Constructeur et Destructeur

49 Template Constructeur et Destructeur Il est souvent nécessaire d initialiser un objet au moment de la création. Parfois il faut même effectuer de l allocation de mémoire. Il est donc nécessaire de disposer d une (ou plusieurs) méthode(s) spéciale(s) pour faire cette initialisation : le Constructeur. De la même façon il faut pouvoir désallouer de la mémoire utilisée par un objet lorsque l on ne l utilise plus. On utilise alors une méthode particulière : le Destructeur

50 Template Constructeur Les constructeurs n ont aucun type de retour (même pas void!!!). Ils portent le même nom que la classe à laquelle ils appartiennent Il sont rarement appelés explicitement par le programmeur. Le compilateur se charge d utiliser le bon constructeur (surcharge) à la création de l objet.

51 Template Constructeur par défaut et par recopie Le Constructeur par défaut Il est utilisé lorsque l objet est instancié sans paramètre. Type () Le Constructeur de recopie Il est utilisé lorsqu un objet est créé à partir d un autre objet de même type. Type ( const Type& unautreobjet)

52 Template Constructeur par recopie Les attributs de l objet passé en paramètre sont recopiés dans les attributs de l objet à créer + Allocation d un nouvel objet en mémoire Les attributs ne sont pas recopiés si l objet passé en paramètre est incomplet On peut accéder directement à l objet passé en paramètre y compris aux champs protected et private

53 Template Destructeur Il n y a qu un seul destructeur par classe!!! Son identificateur est composé du nom de la classe précédé du signe : ~Type(). Les destructeurs n ont pas de paramètres ni de type de retour. Il est préférable de préfixer les destructeurs par le mot clé virtual. (on verra une explication plus tard dans le cours) Les destructeurs ne sont jamais explicitement appellé par le programmeur.

54 Template

55 Template Pour qu une classe soit sous la forme canonique de Coplien, elle doit possèder les quatre méthodes suivantes (Ceci est nécessaire dés lors que la classe dispose de pointeurs sur des parties dynamiques): Constructeur par défaut Constructeur de recopie Destructeur Opérateur d affectation

56 Template Le mot clé this Le mot clé this est le symbole de l auto-référence. Lorsqu une fonction membre est appelée elle reçoit implicitement une référence vers l objet appelant. En général, l accès aux attributs privés se fait de façon directe. Dans certain cas, on a besoin de connaître l adresse de l objet appelant (insertion d un objet dans une liste) this est un pointeur vers cet objet appelant Il ne peut être utilisé que dans les fonctions membres.

57 Template

58 Template Nous avons vu que les méthodes pouvait être surchargées il est également possible d effectuer cette opération avec les opérateurs. Utilité: on peut utiliser le même opérateur pour traiter des éléments de types différents. exemple : a + b peut correspondre à L addition de deux entiers (int) L addition de deux flottant (float) L addition de deux flottant double précision (double)...

59 Template : Exemple Pour redéfinir l opérateur d addition pour une classe point, il suffit de définir une fonction memebre de nom operator+ et prenant 1 paramètre de type point et retournant un objet de même type (c = a + b;). En général on utilise le mot clé operator suivi de l opérateur concerné. Le premier opérande de l opérateur est transmis implicitement comme étant l objet appelant On se retrouve avec la fonction membre suivante : point operator+(point)

60 Template : Exemple Il existe 2 façons d utiliser la méthode : c = a + b; c = a.operator+(b); Dans le cas d objet de grande taille on peut passer les arguments par référence. Ce n est par contre pas systèmatique pour la valeur de retour qui peut poser problème dans certain cas (référence sur un objet local) Il faut se limiter aux opérateurs existants

61 Template

62 Template On a vu que le masquage des données impliquait un accés impossible aux membres privés ou protégés d une classe par une autre classe indépendante. Dans certain cas, il est utile d avoir accès aux membres privés d une autre classe sans changer le masquage. (beurk!!!!) (vecteur et matrice) Pour cela nous allons utiliser des fonctions amies L amitié autorise l accés à tous les membres privés la déclaration se fait par le mot clé friend

63 Template Il existe plusieurs situation d amitié : Fonction indépendante, amie d une classe Fonction membre d une classe amie d une autre classe Fonction amie de plusieurs classes Toute les fonctions membres d une classe, amies d une autre classe

64 Template Fonction indépendante, amie d une classe : Exemple friend point operator+(point,point); Contrairement à la surcharge proposée précédemment, le premier opérande est explicite. Ce n est plus une fonction membre de point. L emplacement de la déclaration d amitié est indifférent. Les deux arguments peuvent éventuellement être passé par référence.

65 Template Fonction membre d une classe amie d une autre classe : Exemple Supposons que nous ayons deux classes A et B et que dans B nous ayons une fonction membre f de prototype : int f(char, A); Si f doit accéder aux champs privés de A elle doit être déclarée comme amie dans A. La déclaration d amitié se fait alors de la façon suivante : friend int B::f(char, A); Il faut avoir compilé la classe B avant la classe A

66 Template Fonction amie de plusieurs classes : Exemple C est le même principe que pour une méthode non membre, amie d une classe. Par exemple : on met friend void f(a,b); dans les deux classes A et B. On définit ensuite la fonction void f(a...,b...) où l on veut.

67 Template Toute les fonctions membres d une classe, amies d une autre classe C est une généralisation du cas fonction membre, amie d une autre classe. On pourrait déclarer amie toutes les méthodes concernées. Il est plus simple de placer dans la classe A l instruction suivante : friend class B; Dans ce cas toutes les fonctions membres de la classe B sont amies de la classe A.

68 Template Templates

69 Template Pour commencer : Les patrons de fonctions Exemple de la fonction min pour les int: int min (int a, int b) { if (a < b) return a; else return b; } ou int min (int a, int b) { return a < b? a : b; }

70 Template Pour commencer : Les patrons de fonctions La même pour les float: float min (float a, float b) { if ( a < b) return a; else return b; } ou float min (float a, float b) { return a < b? a : b; }

71 Template Pour commencer : Les patrons de fonctions On voudrait refaire la même chose pour tous les types. Il y a deux solutions: Faire un copier/coller pour tous les types. (beurk!!!) Utiliser une fonction patron (ou template)

72 Template Pour commencer : Les patrons de fonctions #include <iostream.h> template <classe T> T min (T a, T b) { if (a < b) return a; else return b; } ou template <classe T> T min (T a, T b) { return a < b? a : b; }

73 Template Pour commencer : Les patrons de fonctions la mention template <class T> indique que l on utilise un patron (template) dans lequel apparait un paramètre de type nommé T. L entête précise ensuite que la fonction recoit deux arguments de type T et retourne un résultat du même type.

74 Template Pour commencer : Les patrons de fonctions Utilisation main() { int n=4, c=12; cout "min (n,c) = " min(n,c) " n" ; // int min(int,int) }

75 Template Pour commencer : Les patrons de fonctions Les deux arguments de la fonction doivent impérativement être du même type!!! On peut bien évidemment surcharger les patrons de fonctions Il faut faire attention à la déclaration des variables locales du même type que le paramètre générique. On peut éventuellement spécialiser les patrons (Ne marche pas avec tous les compilateurs)

76 Template Les patrons de classes Il est également possible de paramètrer une famille de fonctions réunies dans une même classe. Il suffit de définir la classe tout entière comme un patron. template <class T> class point {... }

77 Template Les patrons de classes De la même façon que pour les fonctions il peut y avoir plusieurs paramètres. On peut également utiliser un paramètre expression permettant de conditionner les membres de la classe. template <class T, int n> class tableau { T tab[n]; public :... }

78 Template

79 Template La bibliothèque STL (Standard Template Library) est l un des atouts de C++ Elle fournit un ensemble de composants bien structurés, cohérents et facilement adaptables. Il est facile d utiliser les éléments de la STL avec des algorithmes personnels ou des structures de données personnelles.

80 Template Ici, uniquement les généralités vont être présentées. Libre à vous ensuite d approfondir l utilisation. contient 5 types d objets : des containers, des itérateurs, des algorithmes, des objets-fonctions et des adaptateurs. Nous allons essentiellement détailler les 2 premiers.

81 Template : Les containers Les containers ont des objets qui permettent de stocker d autres objets. Ils sont décris par des classes génériques les plus courantes : listes, tableaux, ensembles,... Ces classes possèdent des méthodes pour ajouter, retirer, rechercher, trier... des éléments sans se préoccuper de la gestion de la mémoire. Un certain nombre de méthodes sont commune à tous les containers (push_back()) D autres méthodes sont spécifiques à la nature du container.

82 Template : Les containers Les containers peuvent manipuler n importe quel type de donnée à condition de possèder les méthodes suivantes Un constructeur par défaut Un constructeur par recopie L opérateur d affectation L opérateur d égalité (==) L opérateur inférieur (uniquement pour les tris)

83 Template : Les containers Les différents containers disponibles sont les suivants : vector : implémentation des tableaux list : implémentation de listes doublement chaînées deque : idem vector mais avec mise à jour en début à temps constant set : implémentation des ensembles (sans doublons) multiset ; implémentation des ensembles (avec doublons)

84 Template : Les containers map : ensembles avec une clé unique associé à chacun des éléments multimap : équivalent de multiset pour les map stack : implémentation d une pile (liste LIFO) queue : implémentation d une file (liste FIFO)

85 Template : Les itérateurs Les itérateurs sont une généralisation des pointeurs qui permet au programmeur de travailler avec des container de façon uniforme. Ils permettent de spécifier une position à l intérieur du container. Ils peuvent être incrémentés, déréférencés ou comparés entre eux. Tous les containers possèdent une méthode begin() qui retourne un itérateur sur le premier élément et d une méthode end() qui retourne un itérateur sur une place après le dernier élément.

86 Template : Les itérateurs... list<int> lesentiers; list<int>::iterator it; for (it = lesentiers.begin(); it!= lesentiers.end(); it++) cout < < *it < <endl;...

87 Template

88 Template L héritage est l un des fondamentaux de la programmation orientée objet Il est à la base des possibilités de réutilisation des composants logiciels. Il permet une dérivation d une classe en une classe dérivée plus spécialisée.

89 Template Par exemple : On possède une classe Article comportant les attributs suivants (nom, prixbrut, quantité). On peut très bien construire une classe Boisson à partir de cette classe en y ajoutant uniquement un attribut supplémentaire (volume) Et sans copier-coller sauvage!!!

90 Template : Terminologie La dérivation de classe est la technique qui consite à faire hériter une classe d une autre classe. On dit qu une classe B est dérivée d une classe A si elle en hérite. A est alors appelée la superclasse ou la classe de base de la classe B la déclaration se fait de la manière suivante: class B : <mode_dérivation> A {...}

91 Template : Les modes de dérivation Les modes de dérivations permettent de fixer le statut (public, protected, private) des membres (attributs, fonctions) de la classe B en fonction du statut des membres de la classe A. Les 3 principaux modes de dérivations sont les suivants: L heritage de spécialisation : relation de type est un L héritage d implémentation : relation de type est implémenté en tant que L aggrégation ou Layering (attention ce n est pas tout à fait un héritage)

92 Template : Les modes de dérivation Le mode par défaut en C++ est l heritage d implémentation qui utilise le mot clé private Par contre la méthode d héritage la plus utilisée est l héritage de spécialisation invoquée par le mot clé public

93 Template : Les modes de dérivation Le troisième mode par layering est une solution intermédiaire qui utilise plus le mécanisme de masquage lié à la C.O.O. que la notion d héritage. En C++ il est également possible d hériter de façon protégée en utilisant le mot clé protected.

94 Template : Les modes de dérivation Récapitulatif des modes de dérivations en C++ :

95 Template Lors de la construction d un objet, tous les constructeurs de la hiérarchie d héritage sont automatiquement appelé du plus général au plus particulier Lors de la destruction les destructeurs de la hierarchie sont appelé du plus spécifique au plus général. Lors d une dérivation les méthodes et les attributs sont tous hérités (modulo le mode de dérivation) sauf, les méthodes correspondant à la forme canonique de Coplien.

96 Template : Redéfinition de méthodes Il est possible de redéfinir des méthodes de la classe mère dans une classe fille. L entête de la méthode doit être identique à l originale. La méthode initiale reste utilisable mais il faut la préfixer par le nom de la classe dans laquelle elle a été définie. Lorsqu une méthode surchargée est redéfinie dans une classe fille, toutes les définitions de base sont masquées (pas uniquement celle redéfinie!!!)

97 Template : Conversion entre objets de la même structure hiérachique Soit class B : public A... A a; B b;... a = b ; // ceci est autorisé b = a ; // ceci est rejeté

98 Template : Conversion entre objets utilisant les pointeurs A * pa; B * pb; pa = pb; // est autorisé pb = pa; // est rejeté mais... pb = (B * ) pa // est autorisé par le compilateur!!!!!

99 Template Multiple Il est possible (depuis la version 2) d utiliser de l héritage multiple. Ce principe pose un certain nombre de problèmes de conception et de compilation dans certain cas. On l utilise en général pour bénéficier des avantages d un héritage de spécialisation avec les contraintes d un héritage d implémentation. Dans la plupart des autres cas, le recours à l héritage multiple traduit un problème de conception. Vous verez cette notion en détail en TD.

100 Template, Liaison Statique et Liaison Dynamique

101 Template Type statique, Type dynamique Le type Statique d un objet ou d un pointeur sur un objet (ou d une référence) est le type de sa déclaration dans le programme. Son type Dynamique est le type qu il prend en fonction de ses affectations/manipulations considéront l exemple suivant:

102 Template Type statique, Type dynamique class A {... }; class B : public A {... }; B unb;... A una = unb; A *ptra = &unb; A &refa = unb;}

103 Template Type statique, Type dynamique Les trois affectations sont légitimes, elles font jouer la conversion standard d une classe vers une classe de base. Le type de una ne pose pas problème (c est un A). Par contre les types de ptra et refa sont plus ambigus. (prta pointe-il vers un A ou un B?) Le type statique de *ptra (ce que ptra pointe) et de refa est A, car c est de cette façon qu ils ont été déclarés. Le type dynamique de *ptra et de refa est B, car tel est le type des valeurs effectives de ces variables.

104 Template Type statique, Type dynamique: Le type statique d une expression découle de l analyse du texte du programme, il est connu à la compilation. Le type dynamique, au contraire, est déterminé par la valeur courante de l expression, il peut changer durant l exécution du programme. Par conséquent, un pointeur sur un objet de type A peut pointer vers un objet de type B. C est ce que l on appelle le polymorphisme.

105 Template Liaison statique, Liaison dynamique Par défaut, les méthodes d un objet sont liées statiquement à la compilation. Autrement dit, même si le type dynamique change au cours d un programme, la liaison avec les méthodes ne change pas (statique). Dans le cadre de l exemple précédent, en supposant que les classes A et B disposent chacune d une méthode void Affiche(). L appel de *ptra.affiche() va faire appel à la méthode A::Affiche() même si sont type dynamique est B.

106 Template Liaison statique, Liaison dynamique Il est possible en C++ d effectuer une liaison dynamique avec les méthodes (i.e. au moment de l exécution). Cette liaison est également dite virtuelle. Pour cela, il suffit d utiliser le mot clé virtual lors de la première déclaration de la méthode. (Et à chaque que l on veut en faire bénéficier les descendants d une classe)

107 Template Liaison statique, Liaison dynamique Dans l exemple, il suffit de définir la méthode Affiche de la façon suivante dans A : virtual void Affiche {...}; et de la redéfinir dans B L exécution de *ptra.affiche() fera alors appel à B::Affiche()

108 Template Liaison dynamique : Intérêts La liaison dynamique est très utile lors de traitements génériques sur des objets spécialisés issus de la même classe mère. Il suffit alors d écrire les traitements sur des objets du type de la classe mère et laisser la liaison dynamique faire le reste.

109 Template

110 Template Il est possible de définir dans dans une classe des méthodes virtuelles pures, c est à dire dont l entête est défini mais dont le corps n est pas rédigé. L écriture est la suivante: virtual void affiche() = 0 ; Ceci oblige toutes les classes héritières à redéfinir cette méthode en se conformant au profil énoncé. On dit d une classe qu elle est abstraite à partir du moment où elle possède au moins une méthode virtuelle pure.

111 Template On utilise en général les classes abstraites pour définir une interface commune à toutes les classes filles sans définir le contenu des méthodes qui peut être lié à la nature spécifique de chaque classe. D après la norme ANSI, il n est pas possible d instancier une classe abstraite (pour des raisons évidentes). Il n y a donc pas a priori de constructeur. Cependant, un grand nombre de compilateurs l autorise. Ce qui implique la définition de constructeur permettant d initialiser certains des attributs de la classe abstraite.