« Programmation C++/Les templates » : différence entre les versions
Contenu supprimé Contenu ajouté
Aucun résumé des modifications |
|||
Ligne 1 :
{{Programmation C++}}
==Les templates==
Un template est un patron définissant un modèle de fonction ou de classe dont certaines parties sont des paramètres (type traité, taille maximale).
Le patron de fonction sert à généraliser un même algorithme, une même méthode de traitement à différents cas ou type de données.
Le mot clé <code>template</code> est suivi de la liste des paramètres du patron entre les signes <code><</code> et <code>></code>, suivi de la définition de la fonction ou de la classe.
L'instantiation d'un patron permet la création effective d'une fonction ou d'une classe.
===Patron de fonction===
Un patron de fonction est un modèle de fonction précédé du mot clé <code>template</code> et de la liste des paramètres du patron entre les signes <code><</code> et <code>></code>.
Exemple avec une fonction calculant la valeur maximale d'un tableau de données (le type étant le paramètre du patron de fonction) :
template<class T>
T max(T array[], int length)
{
T vmax = array[0];
for (int i=1 ; i<length ; i++)
if (array[i] > vmax)
vmax=array[i];
return vmax;
}
Le type <code>class</code> utilisé pour le paramètre <code>T</code> est en fait un type de données, par forcément une classe.
Exemple d'utilisation :
int values[]={ 100, 50, 35, 47, 92, 107, 84, 11 };
cout << max(values);
Le compilateur créé une fonction max à partir du type des arguments, en remplaçant le paramètre <code>T</code> par le type <code>int</code> dans le cas précédent.
Après remplacement le compilateur génére la fonction suivante :
int max(int array[], int length)
{
int vmax = array[0];
for (int i=1 ; i<length ; i++)
if (array[i] > vmax)
vmax=array[i];
return vmax;
}
Si on utilise la fonction <code>max</code> avec différents types (<code>int<code>, <code>double</code>, ...), le compilateur génèrera autant de fonctions.
Les patrons permettent donc d'éviter d'écrire plusieurs fonctions pour chaque type de donnée traité.
===Patron de classe===
La déclaration d'un patron de classe utilise une syntaxe similaire.
Exemple d'une classe gérant un tableau de données :
template<class T,int maxsize>
class CDataArray
{
public:
CDataArray();
int getSize();
T get(int index);
bool add(T element); // true si l'élément à pu être ajouté
private:
T array[maxsize];
int length;
}
L'implémentation du constructeur et des méthodes de la classe exige une syntaxe un peu plus complexe.
Par exemple, pour le constructeur :
template<class T,int maxsize>
CDataArray<T,maxsize>::CDataArray()
{
length=0;
}
La première ligne rapelle qu'il s'agit d'un patron de classe.
Le nom du constructeur est précédé du nom de la classe suivi des paramètres du patron de classe, afin que le compilateur déternine de quelle classe il s'agit.
Car en pratique, on peut très bien combiner patron de classe et patron de méthode, par exemple.
Les méthodes sont implémentées de manière identique :
template<class T,int maxsize>
int CDataArray<T,maxsize>::getSize()
{
return length;
}
template<class T,int maxsize>
T CDataArray<T,maxsize>::get(int index)
{
return array[index];
}
template<class T,int maxsize>
bool CDataArray<T,maxsize>::add(T element)
{
if (length>=maxsize) return false;
array[length++]=element;
return true;
}
Contrairement aux patrons de fonctions, l'instanciation d'un patron de classe exige la présence de la valeur des paramètres à la suite du nom de la classe.
Exemple :
CDataArray<int,100> listeNumeros;
listeNumeros.add(10);
listeNumeros.add(15);
cout << listeNumeros.getSize() << endl;
Le compilateur génére une classe pour chaque ensemble de valeurs de paramètres d'instanciation différent.
| |||