12.

Les modèles (templates)

Un modèle est un canevas décrivant une famille de composants : famille de fonctions,

famille de type (class) ...
Les modèles de classes sont abondamment utilisés dans les librairies de classes du
compilateur ou dans les classes vendues dans le commerce.

12.1 Déclarations et définitions.

12.1.1 Modèles de fonctions

Définition d’une fonction générique paramètrée par une constante

template <int N> // définition d'un modèle de fonction

void f ( )
{
float tab[ N ] ;

for ( int i = 0 ; i < N ; i++ ) cin >> tab[ i ] ;

// .....
}

la fonction f est un modèle de fonction qui utilise un tableau de float. La taille du tableau
sera défini plus tard par le "paramètre" N
Jusqu'ici le compilateur connaît la définition d'un modèle de fonction mais aucune fonction
n'est implémentée ( générée ).

f< 10 >() ; // création et appel d'une fonction avec N = 10

f< 50 >() ; // création et appel d'une autre fonction avec N = 50
ici deux fonctions f sont implémentées (générées et exécutables).
Les créations des fonctions sont faites à la compilation en fonction des appels.

12.1.2 Modèles de classe

Définition d’une classe générique "paramètrée" par deux constantes

template <int col, int lig>

class Ecran
{
int colonne, ligne ;
char ecran[ col ][ lig ];
public :
Ecran();
void efface() ;
...
};

Page 1 sur 5
Ecran < 25, 80 > ecranStandard; // création du type Ecran<25,80>
// et création d'une variable de ce type
Ecran < 4, 40 > ecranLCD; // création d'un autre type Ecran<4,40>
// et création d'une variable de ce type

Les fonctions membres définies à l'extérieur de la classe doivent être précédées de la

définition des paramètres
template <int col, int lig>
void Ecran < col, lig > :: efface( )
{
for( int c = 0; c < col; c ++ )
for( int l = 0; l < lig; l ++ ) ecran[ c ][ l ] = ' ';
}

12.2 Paramètres de modèle.

12.2.1 Les paramètres constants.

Les paramètres sont des entiers, énumérations, pointeurs ou référence, mais pas des réels.
Template <int I > f( ) ; // ok
Template <float X> f( ) ; // erreur
Template <float X> class C { } ; // erreur

12.2.2 les paramètres types.

template <class T> // pas une classe mais un type !

T min( T a, T b ) // définition d'un modèle de fonction
{
return a < b ? a : b ;
}

int main()
{
int i, j;
char c, d;
float x, y;
...
i = min<int> ( j, 0 );
// création et appel de la fonction int min( int, int)
c = min<char> ( d, ‘A’ );
// création et appel de la fonction char min( char, char)
x = min<float> ( y, 3.14 );
// création et appel de la fonction float min ( float, float)
return 0;
}

on trouve aussi le mot-clé typename à la place de class

template <typename T> class A { } ;

Les arguments du modèle doivent apparaître obligatoirement dans la liste des paramètres
de l'appel de la fonction

Page 2 sur 5
template <class A, class B, class C>
C min ( A a, B b ) // erreur : C n’est pas un paramètre de min ()
{
Cc=a<b ?a:b;
return c;
}

12.2.3 Déduction des paramètres types.

Le compilateur peut déduire parfois tout seul le type des "paramètres" du modèle au
moment de l'instanciation. L'appel peut alors être simplifié.
// avec la fonction modèle précédente : template <class T> T min( T a, T b )

float x, y ;
x = min( x, y ); // le compilateur en déduit x = min <float> ( x, y )
mais
float x, y ;
x = min( y, 3 ); // erreur, pas de modèle pour ... min ( float, int )
Aucune correspondance ne convient, aucune conversion (cast) n’est appliquée et il y a
erreur de compilation

12.2.4 Paramètres par défaut.

template <class T = int, int taille = 100>
class Tableau
{
T tab[ taille ];
void erreur() ;
public :
T & operator [ ] (int i ) { assert( i < taille ) ; return tab[ i ] ; }
const T & operator [ ] (int i ) const // pour un tableau constant
{ assert( i < taille ) ; return tab[ i ] ; }
};

Tableau < float, 20 > tabReel ;

Tableau < Complex > tabComplex; //  Tableau < Complex, 100 >
Tableau <> tabEntier; //  Tableau < int, 100 >

12.3 Spécialisation partielle d'un modèle.

Il est possible (et parfois obligatoire) de redéfinir une fonction déjà définie par un modèle

template <class T> // modèle générique

T min( T a, T b )
{
return a < b ? a : b ;
}

Page 3 sur 5
template<>
char *min( char *a, char *b )
{
return strcmp( a, b ) < 0 ? a : b ;
}

12.4 Autres exemples.

Classe tableau de tout type
template <class Type>
class Tableau
{
Type *tab;
int taille ;
public :
Tableau( int n ) : taille( n ), tab( new Type[ taille ] ) { }
~Tableau() { delete [] tab };
.....
};

Tableau <int> tabEntier( 5 );

Tableau <Complex> tabComplex( 10 );
Tableau <String> tabString( 100 );

Autre exemple : création d'un modèle de gestion de liste d’élements

Lors de la création de la classe liste, on ne connait pas le type des éléments

template <class Type> // Type sera défini à la demande

class Element
{
Type info;
Element *suivant;
friend class Liste <Type> ; // un objet Liste doit connaitre Element
public :
...
};

template <class Type>

class Liste
{
Element <Type> * premier;
Element <Type> * courant ;
Element <Type> * dernier;
public :
Listee() ;
~Liste();
Type tete() { return premier->info ; }
void ajoute( const Type& );
...
}

Page 4 sur 5
Liste <int> listeEntier;
Liste <Point> listePoint;

Page 5 sur 5