Vous êtes sur la page 1sur 34

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