La Généricité - Template
Objectif : Définir des modules paramétrés par le
type qu’ils manipulent
Il existe : Fonction génerique et des classes
génerique
• Une fonction générique n’est pas utilisable
directement, on appelle patron de fonction
(template)
• La fonction générique est ensuite instanciée
par le type de paramètre qu’elle accepte
1
Exemple
int min (int a, int b)
{ - Grace à la surcharge, on peut écrire
plusieurs fonctions min ou les
return ((a<b)?a:b); instructions sont identiques ( la
} comparaison se fait avec
operateur <)
float min (float a, float b) - Ou bien , on peut écrire une fonction
{ (template et la paramétrer par le
type de données)
return ((a<b)?a:b);
}
template <class T>
String min (string a, string b)
T min (T a, T b)
{ {
return ((a<b)?a:b); return ((a<b)?a:b);
} } 2
L’utilisation du patron de fonction se fait en
instanciant le patron par le type effectif
void main()
{
int a= min<int>(10,20); // appel de la fonction int min (int, int);
float b= min<float>(10.0,20.0); // appel de la fonction float min (float, float)
string c= min<string>(« xxxx», «xyyyy »);
}
- Le type spécifié entre <> est le type qui correspond au paramètre effectif.
- Il peut être omis quand le compilateur peut le déduire sans aucune ambigüité
void main()
{
int a= min(10,20);
float b= min(10.0,20.0);
string c= min(‘xxx’,’xyy’);
} 3
- L’implementation de la fonction devient
indépendante du type de données, elle est
valide avec tous les types qu’on peut comparer
avec l’opérateur <
- Les paramètres de l’appel doivent correspondre à
ceux de l’entête du patron de classe
Problème - La comparaison avec l’opérateur <
retourne la plus petite adresse !
char* c1 = « az »;
char* c2 = « bz »; - Si le type de données à comparer
n’est pas doté de l’opérateur < le
char* c3 = min (c1, c2); résultat sera erroné
4
Solution
A coté du patron de classe il faut écrire une
spécialisation de la fonction min pour le type
char*
char* min(char* x, char* y)
{
return ((strcmp (x, y) < 0) ? x:y;
}
5
Appel d’une fonction Template de la classe
template <class T>
T min (T x, T y)
Fonction Générique
{
return ((x,y)?x:y);
}
char* min(char* a, char* b)
{ Fonction de
spécialisation
return ((strcmp (a, b) < 0) ? a:b;
}
6
class mot {
string*ch;
public :
mot (char*);
Surcharge de
mot operator <(chaine &);
l’opérateur < dans
mot & operator=(const mot&); une classe mot
~mot();
};
mot mot :: operator<(mot & s)
{
operator < de la classe string
mot Res(min(ch, s.ch));
}
void main()
{
mot c1(« az »), c2(« bz »), c3;
c3 = min(c1,c2); Operator < de la classe mot
} - appel du patron de la fonction min
- appel de la surcharge de l’opérateur <
- appel de la spécialisation de la fonction min ( string* min)
7
Classes génériques
- Il est possible de créer des classes générique (
template) pouvant s’appliquer à n’importe quel
type de données
- Cette technique évite de réécrire des fonctions
similaire pour décrire un même comportement
est largement utilisée pour utilisée les types «
containers »
8
Les classes génériques
- On peut définir des classes qui implémentent des
listes , des tableaux, des piles …
indépendamment du type des données qu’ils
contiennent
- On écrit la classe en la paramétrant par un type de
données.
- La classe est ensuite instanciée par des réels, des
entiers, des complexes…
9
template <class T>
class Tableau void main()
{ {
T tab [10]; Tableau <int> A;
public : A[0]= 1;
T & operator [](int); Tableau <char> B;
} B[0] =‘x’;
}
template <class T>
T & Tableau <T> ::operator[] (int
i)
{ return tab [i];}
10
Valeur par defaut
template <class T = int>
class Tableau
{
T tab [10];
public :
T & operator [](int);
}
template <class T>
T & Tableau <T> ::operator[] (int i)
{ return tab [i];}
11
Valeur par defaut
void main()
class complexe {
{ Tableau A;
float imag, reel; A[0]= 1;
public : Tableau <char> B;
complexe (float = 0.0, B[0] =‘x’;
float = 0.0); Tableau <complexe> C;
}; C[0] =complexe (1,2);;
}
12
13
14
15
16
TD 8 - Généricité
Exercice 1 : Définir une classe Tableau générique ayant les méthodes suivantes :
int Rechercher (T element) : retourne l’indice de l’élément, -1 si non trouvé.
void ajouter (T element) : ajoute l’élément si inexistant.
void supprimer (T element) : supprime l’élément si existant.
T& Operator [](int i) : retourne et affecte l’élément à un indice i.
Ostream& operator<<(ostream &o,Tableau t) : affiche tout le tableau
Istream& operator>>(istream &i,Tableau t) : affiche tout le tableau
Appliquer l’exemple du tableau avec des entiers
17
18
Mm
19
Mm
Exercice 2 :
20
Mm
21
Exemple template classe monMap
23
Mm
24
25
26
27
Exercice 3 : Template class pile
Modifier l’exemple pile selon la structure ci-dessous
:
28
Exemple template class pile
29
Exemple Template class pile
30
Exemple Template class pile
31
32
33
34
