Discussion :

[lao.patrick]

Bonjour,

Je n'ai jamais toucher à la notion de template jusqu'aujoud'hui. J'ai un code et je sais pas comment le lire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 template < class MonType > 
      MonType additionner(MonType a, MonType b) 
      { 
          return a+b; 
      }

Merci d'avance pour toute explication. ^^

[Arzar]

Bonjour,
En fait la notion de template est finalement assez simple à comprendre si tu imagines que le compilateur va simplement utiliser ta fonction template comme modèle pour générer des fonctions classiques, sans mystère.
Par exemple, avec le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
template < class MonType > 
MonType additionner(MonType a, MonType b)
{
   return a+b;
} 
int main()
{
   additionner<int>(4, 5);
   additionner<double>(4, 5);
}

Tout se passe comme si le compilateur détecte additioner<int> et additioner<double>, puis génère automatiquement une fonction additionner_int et une fonction additioner_double tout à fait classique en remplacant MonType par int ou par double, et finalement remplace addtioner<Truc> par son équivalent additioner_Truc, comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int additionner_int(int a, int b)
{
   return a+b;
}
 
double additionner_double(double a, double b)
{
   return a+b;
}
 
int main()
{
   additioner_int(4, 5); 
   additioner_double(4, 5); 
}

La génération des fonctions additioner_int/additioner_double est automatique et transparente. En jargon C++ on appelle ça une "instanciation de template".

[koala01]

Salut,

Le principe de base des template est, pour faire simple, de se dire que, si on ne sait pas encore quel sera le type des données manipulées, on sait, par contre, exactement comment elle seront manipulées.

Cela va souvent de paire avec la définition de "prérequis", car, pour pouvoir utiliser une fonction donnée, il faut, généralement, que le type qui sera réellement utilisé présente... un comportement particulier.

Ainsi, dans ton exemple, si tu ne sais pas encre le type des données qui seront additionnées (parce que cela peut, effectivement, être des valeurs numériques, entières ou réelles, mais aussi des type que tu définis toi même), tu sais exactement ce qu'il faudra faire pour les additionner: renvoyer (dans le cas présent) le résultat obtenu par l'utilisation de l'opérateur "+" entre deux termes de même type.

Le prérequis que tu place à l'utilisation de cette fonction est donc, fatalement... que le type dispose d'une définition adaptée de l'opérateur +

Le principe de fonctionnement est, finalement simple: Lorsque le compilateur rencontre l'appel d'une fonction template, comme il dispose déjà de l'ensemble des instructions qu'il doit effectuer, il n'a "plus qu'à"... prendre en compte le type de données réellement manipulé lors de l'appel de la fonction, afin de prévoir "un espace mémoire suffisant" pour représenter cette donnée au moment de la compilation.

Au final, cela permet, avec une seule version de code, d'obtenir une quantité quasi infinie d'implémentations différentes, sans qu'il ne soit nécessaire, pour l'utilisateur, d'écrire la moindre ligne de code supplémentaire (certains présentent les choses sous la forme de "l'écrire une fois, en obtenir tout plein" (write once, get many) )

Le remplacement du type "inconnu" par le type réellement manipulé se faisant au moment de la compilation, il n'y a aucun surcout au niveau de l'appel de la fonction, et ce, d'autant plus, que les fonctions template sont généralement déclarées inline afin d'éviter les problèmes liés au non respect de la règle de la définition unique (one definition rule)

[camboui]

L'exemple de fonction template le plus pédagogique je trouve est la fonction std::sort(). On peut directement la comparer à la fonction qsort().

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void qsort (void * base, size_t num, size_t size,
 int (*comparator)(const void *, const void *));
 
template<class IT> inline void sort(IT _First, IT _Last);
template<class IT, class PR>
 inline void sort(IT _First, IT _Last, PR _Pred);

qsort() impose quelques "cast" un peu contraignants, fait un appel de fonction systématique à chaque comparaison (pas d'appel inline possible, et donc performant, pour les cas simples), et ne permet pas de passer un contexte à la fonction de comparaison (sans parler des paramètres 2 et 3 que l'on confond facilement).
Dans le cas de std::sort(), le compilateur se charge de faire les "cast" à la place du programmeur. La fonction de comparaison est l'operator<(), ou un "foncteur" ou "prédicat" qui permet de travailler avec un contexte pendant les comparaisons.