chapitre x modèles. 2 les modèles (polymorphisme de compilation) comme l’héritage ou le...
TRANSCRIPT
Chapitre XChapitre X
Modèles
2
Les modèles (polymorphisme de compilation)
Comme l’héritage ou le polymorphisme, les templates (ou modèles) représententune technique favorisant la réutilisation et la spécialisation des outils C++.
Rôle Permettent de définir des traitements identiques et applicables à plusieurs typesde données.Utilisent un type paramétré (ou fictif) qui représente le type de donnée qui serachoisi (ou instancié) à l’utilisation du modèle.
S’appliquent aux: fonctionsclassesfonctions membres des classes modèles.
Rôle d’une fonction modèle Permet de définir une famille de fonctions qui partage lemême traitement pour des types de données différents.
Surcharge de fonctions Opérations similaires qui exigent une logique de programmedifférente sur des types de données différents.
Chapitre X - Modèles 3
Les modèles
Rôled’uneclasse
modèle
Fournit la même facilité que les fonctions modèles en donnant la possibilitéde paramétrer un type de donnée aussi bien pour ses données que pour sesfonctions membres.
Le type paramétré peut être utilisé pour les données membres desclasses, comme paramètre ou comme valeur renvoyée par lesfonctions.
Extrait de programme
int Min(int a, int b){
if (a <= b) return a;else return b;
}
float Min(float a, float b){
if (a <= b) return a;else return b;
}
Chapitre X - Modèles 4
Les modèlesCes fonctions réalisent le même traitement pour des types de données différents(short, float, double, etc.)
Une fonction modèle permettrait de définir une seule et unique fonction s’appliquantà tous les types de données primaires.
Un modèle peut utiliser un ou plusieurs types paramétrés qui seront instanciés parun type réel à l’utilisation du modèle.
Les modèles sont utiles pour toutes les abstractions généralisant un type arbitrairec’est-à-dire,
que le comportement ne change pas en fonction du type
Exemple Nous pourrions écrire un seul modèle de fonction pour une fonction de tride tableau et laisser le C++ générer des fonctions de modèle distinctesqui trieraient, l’une un tableau d’int, un autre un tableau de float, …
5
Les fonctions modèlesUne fonction modèle est déclarée en utilisant un ou des types de données paramétrés.
Ces types seront connus au moment de l’appel de la fonction.
syntaxe
template <class type_paramétré, …., class type_paramétré>type_de_retour Nom_de_la_fonction(arguments){
……………}
Nom d’un typeparamétré utilisé
par le modèle
Il ne s’agit pasdes argumentsde la fonction.
La fonction déclarée peut utiliser lestypes fictifs comme type de retour,comme paramètres (arguments) oudans le corps de la fonction.
La déclaration du modèleet la définition de la fonction
peuvent être sur la même ligne.
Un ensemble de types paramétriques différents génèrent un code de fonction différent :Min<int> vs Min<float>.En revanche, 2 emplois de la fonction Min<int> partageront la même fonction.
6
Les fonctions modèlestemplate <class type_primaire>type_primaire Min(type_primaire a, type_primaire b){
if (a <= b) return a;else return b;
}
Extrait de programme
Cette fonction modèle peut être employée avec tous les types de données à lacondition que le traitement réalisé par la fonction soit supporté par ce type.
Il n’existe pas de syntaxe particulière pour appeler une fonction modèle.
int a, b, c; float d, e, f;…..c = Min(a, b); f = Min(d, e);
Par exemple, le type de donnée doit supporter l’opérateur de comparaison <=.Autrement, l’opérateur doit être redéfini.
Le type associé à chaque paramètredu modèle est déduit des argumentslors de l’appel.
On ne peut mélanger les types comme par exemple, f = Min(a, d);Mais on peut spécifier explicitement le type paramétrique:
float g = Min<float>(2, 3.13); // l’entier est converti.
À retrouver dans la spécification.
Chapitre X - Modèles 7
Les fonctions modèlesclass Auto{
protected:char Reference[20+1];char Marque[20+1];int Prix_vente;
public:Auto(char * Ref = "", char * M = "", int Prix = 0);/* Permet de créer un objet Auto.
Pré - Nil.Post - L'objet Auto est créé en tenant compte des
valeurs par défaut pour les différentsarguments. */
Exemple I
Chapitre X - Modèles 8
Les fonctions modèlesvoid Init_Prix_vente(int P);/* Initialise le prix de vente.
Pré - L'objet Auto est créé.Post - Le prix de vente est conservé. */
int Acces_Prix_vente();/* Fournit le prix de vente.
Pré - L'objet Auto est créé.Post - Retourne le prix de vente de l'auto. */
friend bool operator <= (Auto A, Auto B);/* Compare le prix de vente des autos A et B.
Pré - Les objets A et B sont créés.Post - Retourne true si le prix de vente de A est <=
au prix de vente de B. */};
Chapitre X - Modèles 9
Les fonctions modèlesclass Auto_usagee : public Auto{protected:
char Nom_Ancien_Proprietaire[20+1];char Prenom_Ancien_Proprietaire[20+1];int Cout_achat;
public:Auto_usagee(char * Ref = "", char * M = "", int Prix = 0,
int Cout = 0, char * Nom = "", char * Prenom = "");/* Permet de créer un objet Auto_usagee.
Pré - Nil.Post - L'objet Auto_usagee est créé en tenant compte des
valeurs par défaut pour les différents arguments.*/
Chapitre X - Modèles 10
Les fonctions modèlesvoid Init_Cout_achat(int C);/* Initialise le coût d'achat.
Pré - L'objet Auto_usagee est créé.Post - Le coût d'achat est conservé. */
int Acces_Cout_achat();/* Fournit le coût d'achat.
Pré - L'objet Auto_usagee est créé.Post - Retourne le coût d'achat de l'auto usagée. */
};
Chapitre X - Modèles 11
Les fonctions modèlesLe fichier Auto.cpp reste inchangé.
#include <iostream.h>#include "Auto.h"template <class type_primaire>type_primaire Min(type_primaire A, type_primaire B){
return (a <= b) ? a : b;}bool operator <= (Auto A, Auto B){
return (A.Prix_vente <= B.Prix_vente) ? true : false;}
Le fichier Application Auto.cpp devient :
Chapitre X - Modèles 12
Les fonctions modèles
int main(){ Auto A("R025", "Honda Civic", 22500);
Auto_usagee B("C25", "Toyota", 18500, 12550, "Duval", "Luc");Auto_usagee C("D123", "Capri");cout << A.Acces_Prix_vente() << endl;cout << B.Acces_Prix_vente() << endl;cout << B.Acces_Cout_achat() << endl;cout << C.Acces_Prix_vente() << endl;cout << C.Acces_Cout_achat() << endl;if (B <= A) cout << "B coute moins cher que A " << endl;if (B <= C) cout << "B coute moins cher que C " << endl;return 0;
}
Chapitre X - Modèles 13
Les fonctions modèlesExemple II
#include <iostream.h>
template <class T>void ImpressionTableau( const T * tableau, const int compte){
for ( int i = 0; i < compte; i++ )cout << tableau[ i ] << " " ;
cout << endl;}
Chapitre X - Modèles 14
Les fonctions modèlesExemple II
void main(){
const int Nbentiers = 5;int a[Nbentiers] = { 1, 2, 3, 4, 5 };ImpressionTableau(a, Nbentiers);
const int Nbreels = 7;int b[Nbreels] = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };ImpressionTableau(b, Nbreels);
const int Nbcaracteres = 8;int c[Nbcaracteres] = { "BONJOUR" };ImpressionTableau(c, Nbcaracteres);
}
1 2 3 4 51.1 2.2 3.3 4.4 5.5 6.6 7.7B O N J O U R
15
Surcharger des fonctions modèlesUne fonction modèle peut être surchargée de plusieurs façons :
Créer d’autres modèles de fonctions qui portent le même nom de fonction maisqui utilisent des paramètres différents.
Ex. : La fonction modèle ImpressionTableau pourrait être surchargé par uneautre fonction modèle ImpressionTableau qui accepte les paramètressupplémentaires indiceInf et indiceSup, destinés à indiquer la portiondu tableau à imprimer.
Créer d’autres fonctions qui ne sont pas basées sur le modèle du même nom et quiutilisent des arguments de fonction différents.
Ex. : La fonction modèle ImpressionTableau pourrait être surchargé par uneautre fonction ImpressionTableau qui ne respecte pas le modèle et quiimprime spécifiquement un tableau de chaînes de caractères sous uneforme particulière.
Lorsque le compilateur doit choisir entre 2 fonctions ayant les mêmes arguments,la fonction non modèle est choisie.
Chapitre X - Modèles 16
Les classes modèles
syntaxe
template <class type_paramétré, …., class type_paramétré>class Nom_classe{
……………};
Nom d’un typeparamétré utilisé
par le modèle
Les types fictifs spécifiéspeuvent être utilisés pourdéfinir des données ou parles fonctions membresde la classe.
SyntaxeDéfinition du corps des fonctions membres
template <class type_paramétré, …., class type_paramétré>type_de_retourNom_classe<type_paramétré, …., type paramétré>::Nom_fonction(arguments){
……………};
idem
idemIdem sans le mot
class
Note : Le mot-clé class peut êtreremplacé par typename.
Chapitre X - Modèles 17
Les classes modèlesUne classe modèle peut également contenir des fonctions membres qui n’utilisent pasles types paramétrés.Le corps de la fonction doit respecter quand même la contrainte liée au nom completde la fonction membre.
Exemple tiré de Stéphane Dupin, Le langage C++, pp. 362-365, 1999.
template <class T>class Tableau{
private: T Valeurs[10];int indice;
public: Tableau();void Ajouter(T v);T Renvoyer(int i);int NombreElement();
};
Chapitre X - Modèles 18
Les classes modèles
template <class T>void Tableau<T>::Ajouter(T v){
if (indice < 10){
Valeurs[indice] = v;indice++;
}else cout << "Tableau plein" << endl;
}
template <class T>T Tableau<T>::Renvoyer(int i){
if (i < indice)return Valeurs[i];
elsereturn 0;
}
La contrainte liée au nom complet des fonctions des classes modèles s’appliquentégalement aux méthodes qui n’utilisent pas le type paramétré.
19
Les classes modèles
template <class T>Tableau<T>::Tableau(){
indice = 0;}
template <class T>int Tableau<T>::NombreElement(){
return indice;}
Autre exemple :
Un modèle de classe Pile peut ainsi devenir la base de la création de nombreusesclasses Pile (Pile de char, Pile d’employes, …).
Chapitre X - Modèles 20
Création d’objets statiques ou dynamiques
Il faut explicitement indiquer la valeur des types paramétrés au moment de lacréation des objets de cette classe.
Tableau<int> TabEntiers;
…….
Tableau<char> * pTabCaracteres;pTabCaracteres = new Tableau<char>;
…….
delete pTabCaracteres;
Mis à part leurs créations, les objetsde type modèle s’utilisent de la mêmemanière que n’importe quel objet.
Création d’un alias de nom long à l’aide de typedef : typedef Tableau<int> tabint;tabint TabEntiers;
Chapitre X - Modèles 21
Exemple#include <iostream.h>template <typename T>class Couple{
private : T premier; T deuxieme;public : Couple(T a, T b);
T Acces_premier() const;T Acces_deuxieme() const;
};template <typename T>Couple <T>::Couple(T a, T b){
premier = a; deuxieme = b;}template <typename T>T Couple <T>::Acces_premier() const{
return premier;}
Chapitre X - Modèles 22
Exemple (suite)template <typename T>T Couple <T>::Acces_deuxieme() const{
return deuxieme;}template <typename T>Couple<T> minmax(T * v, int L){
T min = v[0]; T max = v[0];for (int i = 0; i < L; i++){
if (v[i] < min) min = v[i]; if (v[i] > max) max = v[i];};return Couple<int>(min, max);
}void main(){
int tab[10] = {3, 2, 5, 6, 9, 7, 1, 8, 10, 4};Couple<int> C = minmax(tab, 10);cout << C.Acces_premier() << " " << C.Acces_deuxieme() << endl;
}
Chapitre X - Modèles 23
Les classes et les fonctions modèles
template <class type_numerique>class Vecteur{/*
Spécification fonctionnelle de la classe " Vecteur "
Composantes :Chaque composante est une valeur numérique. Lescomposantes sont de même type.
Structure : Il existe une relation linéaire (structure) entreles composantes d'un vecteur.
*/
Chapitre X - Modèles 24
Les classes et les fonctions modèles
protected:int n; /* Longueur du vecteur */type_numerique * v; /* Pointeur vers le vecteur de */
/* composantes. */public:
Vecteur(int L = 3);/* Constructeur permettant de créer un vecteur de longueur
L > 0 (3 par défaut) dont les composantes sont des valeursnumériques.
Pré - L > 0.Post - Le vecteur de longueur L est le vecteur nul.*/
Chapitre X - Modèles 25
Les classes et les fonctions modèles
type_numerique & operator[] (int i);/* Donne accès à la ième composante du vecteur.
Pré - Le vecteur a déjà été créé et 1 <= i <= longueur du vecteurPost - Donne accès à la ième composante du vecteur. */
friend int dim(Vecteur P);/* Donne accès à la longueur du vecteur.
Pré - Le vecteur a déjà été créé.Post - Retourne la longueur du vecteur. */
void Detruire_vecteur();/* Permet de détruire le vecteur et de libérer l'espace correspondante.
Pré - Le vecteur a déjà été créé.Post - Le vecteur n'existe plus. */
Chapitre X - Modèles 26
Les classes et les fonctions modèles
type_numerique operator * (Vecteur P);/* Fournit le produit scalaire du vecteur courant avec le vecteur P où
les composantes des 2 vecteurs sont de même type.Pré - Le vecteur courant et le vecteur P ont déjà été créés et sont
de même longueur. Les éléments sont de même type.Post - Retourne le produit scalaire des 2 vecteurs. */
void operator * (type_numerique Lambda);/* Multiplie chaque composante du vecteur par le scalaire "Lambda"
Pré - Le vecteur a déjà été créé. Le scalaire et les composantesdu vecteur sont de même type.
Post - Chaque composante du vecteur a été multipliée par"Lambda". */
Chapitre X - Modèles 27
Les classes et les fonctions modèles
void operator += (Vecteur P);/* Permet d'additionner le vecteur P au vecteur courant. Les
composantes des 2 vecteurs sont de même type.Pré - Le vecteur courant et le vecteur P ont déjà été créés et sont
de même longueur.Post - Additionne P au vecteur courant. */
void operator -= (Vecteur P);/* Permet de soustraire le vecteur P du vecteur courant. Les
composantes des 2 vecteurs sont de même type.Pré - Le vecteur courant et le vecteur P ont déjà été créés et sont
de même longueur.Post - Soustrait P du vecteur courant. */
};
Chapitre X - Modèles 28
Les classes et les fonctions modèles
Fichier « Calcul_vectoriel.cpp »
#include <iostream.h>#include "Vecteur.h"
template <class type_numerique>Vecteur<type_numerique>::Vecteur(int L):n(L){
int i;v = new type_numerique[n];for (i = 0; i < n; i++) v[i] = 0;
}
Chapitre X - Modèles 29
Les classes et les fonctions modèles
template <class type_numerique>type_numerique & Vecteur<type_numerique>::operator[](int i){
return v[i - 1];}
template <class type_numerique>int dim(Vecteur<type_numerique> P){
return P.n;}
Chapitre X - Modèles 30
Les classes et les fonctions modèles
template <class type_numerique>void Vecteur<type_numerique>::Detruire_vecteur(){
delete v;}template <class type_numerique>type_numerique Vecteur<type_numerique>::operator * (Vecteur P){
int i;type_numerique somme; somme = 0;for (i = 0; i < n; i++) somme = somme + P[i+1] * (*(v + i));return somme;
}
Chapitre X - Modèles 31
Les classes et les fonctions modèles
template <class type_numerique>void Vecteur<type_numerique>::operator * (type_numerique Lambda){
for (int i = 0; i < n; i++)(*(v+i)) = (*(v+i)) * Lambda;
}
template <class type_numerique>void Vecteur<type_numerique>::operator += (Vecteur P){
for (int i = 0; i < n; i++)(*(v+i)) = (*(v+i)) + P[i+1];
}
Chapitre X - Modèles 32
Les classes et les fonctions modèles
template <class type_numerique>void Vecteur<type_numerique>::operator -= (Vecteur P){
for (int i = 0; i < n; i++)(*(v+i)) = (*(v+i)) - P[i+1];
}void main(void){
int i;int L = 3;Vecteur<float> P;Vecteur<float> Q;
Chapitre X - Modèles 33
Les classes et les fonctions modèles
for (i=1; i <= L; i++){
P[i] = (float) i;Q[i] = 0.1f;
}for (i=1; i <= L; i++) cout << P[i] << " ; » << Q[i] << " ; " << endl;cout << "Longueur du vecteur: " << dim(P);cout << "Produit scalaire : " << P * Q;Q * 0.2f; cout << "Produit scalaire : " << P * Q;P += Q; cout << "Produit scalaire : " << Q * P;P -= P; cout << "Produit scalaire : " << P * Q;}
Chapitre X - Modèles 34
Définition de paramètres en plus de types paramétrés
En plus de spécifier les types paramétrés, vous pouvez utiliser la liste d’argumentsd’un modèle pour définir des paramètres dont le type est figé.
La valeur de ces arguments devra être passée à l’instance du modèle, exactement dela même manière que les valeurs des types paramétrés.
Ainsi, la classe modèle dispose d’arguments qui peuvent être utilisés par lesdonnées et les fonctions membres de la classe.
Comme les arguments des fonctions, ces variables peuvent avoir une valeur pardéfaut.
Chapitre X - Modèles 35
Définition de paramètres en plus de types paramétrés
template <class type_numerique, int n = 3>class Vecteur{/*
Spécification fonctionnelle de la classe " Vecteur "
Composantes :Chaque composante est une valeur numérique. Lescomposantes sont de même type.
Structure : Il existe une relation linéaire (structure) entreles composantes d'un vecteur.
*/
Chapitre X - Modèles 36
Définition de paramètres en plus de types paramétrés
protected:type_numerique v[n]; /* Un vecteur de composantes.*/
public:Vecteur();/* Constructeur permettant de créer un vecteur de longueur
n > 0 (3 par défaut) dont les composantes sont desvaleurs numériques.
Pré - n > 0.Post - Le vecteur de longueur n est le vecteur nul.*/
idem
Chapitre X - Modèles 37
Définition de paramètres en plus de types paramétrés
Fichier « Calcul_vectoriel.cpp »
#include <iostream.h>#include "Vecteur.h"
template <class type_numerique, int n>Vecteur<type_numerique, n>::Vecteur(){
for (int i = 0; i < n; i++) v[i] = 0;}
Chapitre X - Modèles 38
Définition de paramètres en plus de types paramétrés
template <class type_numerique, int n>type_numerique & Vecteur<type_numerique, n>::operator[](int i){
return v[i - 1];}
template <class type_numerique, int n>int dim(Vecteur<type_numerique, n> P){
return n;}
Chapitre X - Modèles 39
Définition de paramètres en plus de types paramétrés
template <class type_numerique, int n>void Vecteur<type_numerique, n>::Detruire_vecteur(){
delete v;}template <class type_numerique, int n>type_numerique Vecteur<type_numerique, n>::operator * (Vecteur P){
int i;type_numerique somme; somme = 0;for (i = 0; i < n; i++) somme = somme + P[i+1] * (*(v + i));return somme;
} etc.
Chapitre X - Modèles 40
Définition de paramètres en plus de types paramétrés
void main(void){
int i;const int L = 3;Vecteur<float> P;Vecteur<float, L> Q;
}
On pourrait aussi avoir les déclarations suivantes:Vecteur <double, 10> R;Vecteur <int> * pTabEntiers;pTabEntiers = new pTabEntiers<int, 12>;
On peut spécifier la taille d’un vecteurau moment de la compilation.
Chapitre X - Modèles 41
La classe PileLa classe Piletemplate <class element>class pile{/* Spécification fonctionnelle de la classe " pile ".
Éléments : Chaque sommet de la pile renferme l'adresse d'unélément et non pas l'élément lui-même. Le type dechaque élément de la pile peut être quelconque.
Structure : Les éléments sont reliés entre eux permettant dedéterminer l'ordre d'arrivée des éléments dans lapile. */
Chapitre X - Modèles 42
La classe PileLa classe Pileprotected:
struct sommet_pile{
element * pElement;struct sommet_pile *suivant;
};struct sommet_pile * pPile;
public:void Creer_pile();/* Permet de créer une pile vide.
Pré - Nil.Post - La pile existe et est vide. */
Chapitre X - Modèles 43
La classe PileLa classe Pilevoid Inserer(element * pElement);/* Insérer l'adresse d'un élément dans la pile.
Pré - La pile a déjà été créée et n'est pas pleine.Post - La pile renferme pElement et l'interprète comme étant
l'adresse de l'élément le plus récent inséré dans la pile.*/
element * Enlever();
/* Enlever un élément de la pile.Pré - La pile a déjà été créée et n'est pas vide.Post - L'adresse de l'élément le plus récent inséré dans la pile
est retourné; cet élément ne fait plus partie de la pile.*/
Chapitre X - Modèles 44
La classe PileLa classe Pilebool Pile_vide();/* Vérifier si la pile est vide ou non.
Pré - La pile a déjà été créée.Post - Si la pile ne possède aucun élément
alors retourner truesinon retourner false. */
bool Pile_pleine();/* Vérifier si la pile est pleine ou non.
Pré - La pile a déjà été créée.Post - Si la pile a atteint sa capacité maximale
alors retourner vraisinon retourner faux. */
Chapitre X - Modèles 45
La classe PileLa classe Pilevoid Vider_pile();/* Vider la pile.
Pré - La pile a déjà été créée.Post - La pile est vide. */
};
#include <iostream.h>#include "Pile.h"template<class element>void pile<element>::Creer_pile(){
pPile = NULL;}
Chapitre X - Modèles 46
La classe PileLa classe Piletemplate<class element>void pile<element>::Inserer(element * pElement){
struct sommet_pile *pe = new sommet_pile;(*pe).pElement = pElement;(*pe).suivant = pPile;pPile = pe;
}
Chapitre X - Modèles 47
La classe PileLa classe Piletemplate<class element>element * pile<element>::Enlever(){
element * pElement;struct sommet_pile *pe = NULL;pElement = (*pPile).pElement;pe = pPile;pPile = (*pPile).suivant;delete(pe);return pElement;
}
Chapitre X - Modèles 48
La classe PileLa classe Piletemplate<class element>bool pile<element>::Pile_vide(){
if (pPile == NULL ) return true;else return false;
}template<class element>bool pile<element>::Pile_pleine(){
/* Il n'y a aucune façon de tester si la liste chaînée est pleine i.e.s'il existe encore de l'espace disponible pour un autre sommet.*/return false;
}
Chapitre X - Modèles 49
La classe PileLa classe Piletemplate<class element>void pile<element>::Vider_pile(){
element * pElement;while (Pile_vide() == false) pElement = Enlever();
}void main(){
int i=0, j=1, k=2; float a=0.0f, b=0.1f; char u = 'a';pile<int> Pile_entiers;pile<float> Pile_reels;pile<char> Pile_caracteres;
Chapitre X - Modèles 50
La classe PileLa classe PilePile_entiers.Creer_pile(); Pile_reels.Creer_pile();Pile_caracteres.Creer_pile();Pile_entiers.Inserer(&i); Pile_entiers.Inserer(&j);Pile_entiers.Inserer(&k); Pile_reels.Inserer(&a);Pile_reels.Inserer(&b); Pile_caracteres.Inserer(&u);cout << * Pile_entiers.Enlever(); cout << * Pile_entiers.Enlever();cout << * Pile_entiers.Enlever(); cout << * Pile_reels.Enlever();cout << * Pile_reels.Enlever(); cout << * Pile_caracteres.Enlever();if ((Pile_entiers.Pile_vide() == true) &&(Pile_reels.Pile_vide() == true)
&& (Pile_caracteres.Pile_vide() == true))cout << "Les 3 piles sont vides.";
} pas de conversion
Chapitre X - Modèles 51
Modèles et membres statiquesModèles et membres statiquesUne classe modèle peut contenir des données et fonctions membres statiques.
Ex.: template <class T>class Salle_attente{
public:static int Nb_chaises_disponibles;……….
};template <class T>int Salle_attente<T>::Nb_chaises_disponibles = 12;
Une donnée membre statique existe pour chaque instance du modèle.Tous les objets de type Salle_attente<Clients_Pharmacie> partagent la mêmevariable statique et tous les objets de type Salle_attente<Clients_Dentiste>partagent la leur.
Chapitre X - Modèles 52
Modèles et héritageModèles et héritage
Les modèles et l’héritage se retrouvent de différentes façons :
un modèle de classe (classe générique) dérivé d’une classe spécifique d’un modèle,
un modèle de classe (classe générique) dérivé d’une classe non spécifique à unmodèle,
une classe spécifique d’un modèle dérivée d’un modèle de classe (classe générique),
une classe non spécifique à un modèle dérivée d’un modèle de classe(classe générique).
Les modèles ne préservent pas l’héritage.
Exemple : Même si Gestionnaire dérive de Employe, il n’y a aucunerelation entre Vecteur<Gestionnaire> et Vecteur<Employe>.
Chapitre X - Modèles 53
Modèles et amitiéModèles et amitiéL’amitié peut être établie entre un modèle de classe et
- une fonction globale,- une fonction membre d’une autre classe
(laquelle peut être une classe spécifique à un modèle),- une classe toute entière
(laquelle peut être une classe spécifique à un modèle).
Chapitre X - Modèles 54
Modèles et amitiéModèles et amitié
Exemple I
Soit un modèle de classe pour la classe Essai, déclaré par :
template <class T> class Essai
une déclaration d’amitié de la forme
friend void f();
fait de la fonction f une amie de toute classe spécifique au modèle de la classe Essai.
Chapitre X - Modèles 55
Modèles et amitiéModèles et amitié
Exemple II
Soit un modèle de classe pour la classe Essai, déclaré par :
template <class T> class Essai
une déclaration d’amitié de la forme
friend void g(Essai < T > & Obj);
pour un type T particulier tel que float fait de la fonction g (Essai < float > & Obj)une amie de Essai< float > seulement.
Chapitre X - Modèles 56
Modèles et amitiéModèles et amitié
Exemple III
Soit un modèle de classe pour la classe Essai, déclaré par :
template <class T> class Essai
une déclaration d’amitié de la forme
friend void Autre::h();
fait de la fonction membre h de la classe Autre une amie de toute classe spécifiqueau modèle de la classe Essai.
Chapitre X - Modèles 57
Modèles et amitiéModèles et amitié
Exemple IV
Soit un modèle de classe pour la classe Essai, déclaré par :
template <class T> class Essai
une déclaration d’amitié de la forme
friend void Autre< T >::K(Essai< T > & Obj);
pour un type T particulier tel que float, fait de la fonction membreAutre< float >::K(Essai< float > & Obj)
une fonction amie de la seule classe spécifique de modèle Essai<float>.
Chapitre X - Modèles 58
Modèles et amitiéModèles et amitié
Exemple V
Soit un modèle de classe pour la classe Essai, déclaré par :
template <class T> class Essai
une seconde classe Tentative peut être déclarée par
friend class Tentative;
rendant toute fonction membre de la classe Tentative amie de toute classe spécifiqueau modèle de classe Essai.
Chapitre X - Modèles 59
Modèles et amitiéModèles et amitié
Exemple VI
Soit un modèle de classe pour la classe Essai, déclaré par :
template <class T> class Essai
une seconde classe Tentative peut être déclarée par
friend class Tentative<T>;
ensuite, lorsqu’une classe spécifique à la classe Essai est instanciée avec un typeparticulier de T tel que float, tous les membres de la classe Tentative<float>deviennent amis de la classe Essai<float>.