Chapitre 7:

Les Templates: Fonctions génériques et modèles

7.1 Introduction

En programmation, on a souvent tendance à reproduire du code (le

dupliquer) pour pouvoir gérer plusieurs types d’arguments.
Supposons que l’on souhaite développer la fonction carre().
On va écrire :
int carre (int i)
{
return (i*i);
}
long carre(long l) * Redondance
{ * taille de l’exécutable
return(l*l);
}
double carre(double d)
{
return(d*d);
}
1
7.2 Les fonction génériques ou Templates

Une solution pour éviter la duplication de codes pour des fonctions qui agissent sur
des arguments de type différents consiste à écrire une fonction générique.

La syntaxe est la suivante:

template <class T> T nom_fonction(T parametre)

{
..
}

Cette forme permet de paramétrer le type dans une fonction .

T étant le type abstrait du paramètre de la fonction, il remplace le type spécifique de
la version sans template.

2
7.3 Exemple (1)

Version 2 de la template

3
Exemple 2

Version 2 de minimum

4
Exemple 3

5
7.4 Modèle supportant les types multiples

Pour un modèle à 2 types la syntaxe est:

template <class T1,class T2> <type valeur de retour > nom_fonction (parametres)
{
}
Le type de la fonction de retour peut évidement être T1 ou T2 ou un autre type
reconnu par le compilateur (int, long , .., ou une classe définie )

6
7.5 Exemple (1)

Attention du résultat!!
Le type du résultat est
le type du premier
argument de la fonction
7
7.5 Exemple (2)

Le résultat est toujours de type double

8
7.6 Surcharge explicite d’une fonction générique

Il est possible de définir un modèle générique pour une fonction et prévoir une
version pour une configuration spécifique.

template <class T> T <nom_fonction(T p) // Le modèle général

{
}

int nom_fonction (int p) // Le cas spécifique int

{
}

Il s’agit d’une surcharge de la fonction pour une configuration de type.

9
7.7 Exemple de surcharge d’une fonction générique

10
11
On souhaite empêcher la permutation de ville, il faudrait dans ce cas surcharger la
fonction permuter pour le type ville.

On aura donc :

12
7.8 Application

Programme de Tri.

Ecrire une fonction générique permettant de trier un tableau quelque soit

sont type.
Le type des éléments du tableau peut en effet être:
int
long
..
ville
etudiant
produit
etc..

Au lieu d’écrire des version spécifiques de la fonction tri, on va définir un

modèle (template) qui opère quelque soit le type du tableau.

13
14
Fonction main pour trier des éléments de type int

15
etudiant.h

16
17
7.9 Les modèles de classe

Les templates s’appliquent aussi pour les classes ce qui permet d’éviter la
duplication de code pour des classes similaires .
Exemple:

class courte_distance class longue_distance

{ {
private: private:
int distance; long distance;
public: public:
courte_distance(int distance) longue_distance(long distance)
{ {
this->distance=distance; this->distance=distance;
} }
void view() void view()
{ {
cout << « Distance: »<<distance; cout << « Distance:<<distance;
} }
}; }:

18
On peut les remplacer avec la template suivante:

Template <class T> class distance

{
private:
T distance;
public:
distance(T distance)
{
this->distance=distance;
}
view()
{
cout << « Distance: »<<distance;
}
];

19
20
7.10 Les arguments dans une template

Il est possible dans une template de classe de définir des arguments.

Exemple:
Template <class T>, int dim=64>class test
{
private:
T *t=new T [dim];
public:
..
};
Pour créer une instance on peut utiliser dans ce cas:
test<int,1024> a;

21
7.11 Classe générique avec 2 types d’arguments

syntaxe:
Exemple
Template <class T1,class T2> class deux
{
private:
T1 a;
T2 b;
public:
deux(T1 a, T2 b)
{
this->a=a;
this->b=b;
}
};

22
23
24