Template (programmation)

La déclaration d'une classe ou fonction générique doit être précédée par :

template <typename T, typename U>

Le mot clé class peut être utilisé à la place de typename. Les types T et U pourront alors être utilisés dans le corps de la classe ou de la fonction.

Avec les classes, on peut aussi se servir de la généricité pour utiliser une valeur constante :

template <typename T, int N>

La valeur entière N pourra être utilisée dans la classe comme s'il s'agissait d'un entier constant.

Chaque type ou valeur déclaré peut posséder une valeur par défaut, comme les arguments muets d'une fonction.

Il y a deux types de patrons.

Un patron de fonction pourra supporter n'importe quel type pour ses arguments. Par exemple :

template <typename T>
inline T min(const T &x, const T &y)
{
    return (x < y) ? x : y;
}

Voici un exemple d'utilisation :

#include <iostream>
int main ()
{
    // Appel de min<int>
    std::cout << min(-20, 5) << ' ';
    // Appel de min<double>
    std::cout << min(6.4, -17.3) << ' ';
    // Appel de min<double> ; le type doit être précisé pour pallier l'ambiguïté
    std::cout << min<double>(6.96e2, 48) << std::endl;
}

Le programme affichera la ligne suivante :

-20 -17.3 48

Le type T est défini par les paramètres donnés à la fonction min. Une fonction générique doit donc comporter un argument de chacun des types qu'elle compte utiliser pour pouvoir être compilée.

Cependant, si plusieurs arguments définissent un même type T pour la fonction mais ne sont pas du même type, le type utilisé doit être explicitement indiqué (les arguments seront donc convertis dans ce type si nécessaire).

Dans la STL, on trouve des patrons de fonction en particulier avec les algorithmes du fichier d'en-tête <algorithm>. Par exemple :

• extrema : std::min, std::max ;
• compter/chercher : std::count, std::find ;
• modification : std::copy, std::fill, std::swap ;
• tri : std::sort…

Déclarer une classe comme patron lui permet en particulier de pouvoir posséder des membres d'un type défini par l'utilisateur. Par exemple[3] - [4] :

#include <cstdarg>
template <typename T, int N>
class Tab
{
    /* Membres */
        // Ici est stocké le tableau avec N éléments du type T
        T tab[N];
        // Utile pour l'affichage
        const char *separateur;
    public :
    /* Constructeurs */
        // Constructeur par défaut
        Tab<T,N> (const T &t=0) : separateur(" ")
        {
            for (int i=0; i<N; i++)
                tab[i]=t;
        }
        // Ce constructeur permet d'initialiser les éléments du tableau
        Tab<T,N> (const T &t1, const T &t2, ...) : separateur(" ")
        {
            tab[0]=t1, tab[1]=t2;
            va_list args;
            va_start (args,t2);
            for (int i=2; i<N; i++)
              tab[i]=va_arg(args,T);
            va_end (args);
        }
        // Constructeur par recopie (notez qu'il s'agit de celui par défaut)
        Tab<T,N> (const Tab<T,N> &t) : tab(t.tab), separateur(t.separateur)
        {}
        // Surdéfinition de l'opérateur d'affectation (notez qu'il s'agit de celle par défaut)
        Tab<T,N> &operator= (const Tab<T,N> &t)
        {
            for (int i=0; i<N; i++)
                tab[i]=t.tab[i];
            return *this;
        }
    /* Fonctions d'accès et d'altération */
        int size () const
        { return N; }
        const char *obt_sep () const
        { return separateur; }
        void config_sep (const char *nouv_sep)
        { separateur=nouv_sep; }
        const Tab<T,N> &operator() (const char *nouv_sep)
        { separateur=nouv_sep; return *this; }
        T &operator[] (int i)
        { return tab[i]; }
        const T &operator[] (int i) const
        { return tab[i]; }
        template <int N2> operator Tab<T,N2> ()
        {
        	Tab<T,N2> t;
        	for (int i=0; i<((N<N2)? N:N2); i++)
        		t.tab[i]=tab[i];
    		return t;
        }
};

La notation Tab<T,N> est ici redondante et pourrait être remplacée simplement par Tab.

Voici un exemple d'utilisation :

#include <iostream>
#include <algorithm>
// Surcharge de l'opérateur de décalage binaire vers la gauche
 // pour pouvoir envoyer nos tableaux sur un flot de sortie
template <typename T, int N>
std::ostream &operator<< (std::ostream &sortie, const Tab<T,N> &tab)
{
    for (int i=0; i<N; i++)
        sortie << tab[i] << ((i<N-1)? tab.obt_sep():"");
}
int main ()
{
    /* Deux listes de cinq flottants */
    Tab<double,5> liste1, liste2(66.17,4.3e3,22e5,1e-4,liste1[4]);
    liste1=liste2;
    for (int i=0; i<liste1.size(); i++)
        liste1[i]*=1.5;
    std::cout << liste1 << std::endl;
    /* Des tirets pour séparer */
    std::cout << Tab<char,37>('-')("") << std::endl;
    /* Calculs sur un tableau à deux dimensions (19x19) : création de dix carrés imbriqués */
    Tab<Tab<int,19>,19> carres;
    for (int i=0; i<=carres.size()/2; i++)
        for (int j=0; j<carres[i].size(); j++)
            carres[i][j]=std::max(9-i,std::abs(9-j));
    for (int i=0; i<carres.size(); i++)
        carres[18-i]=carres[i];
    carres.config_sep("\n");
    std::cout << carres << std::endl;
}

Ceci affichera :

99.255 6450 3.3e+06 0.00015 0
-------------------------------------
9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9
9 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9
9 8 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 9
9 8 7 6 6 6 6 6 6 6 6 6 6 6 6 6 7 8 9
9 8 7 6 5 5 5 5 5 5 5 5 5 5 5 6 7 8 9
9 8 7 6 5 4 4 4 4 4 4 4 4 4 5 6 7 8 9
9 8 7 6 5 4 3 3 3 3 3 3 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 2 2 2 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 1 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 1 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 2 2 2 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 3 3 3 3 3 3 4 5 6 7 8 9
9 8 7 6 5 4 4 4 4 4 4 4 4 4 5 6 7 8 9
9 8 7 6 5 5 5 5 5 5 5 5 5 5 5 6 7 8 9
9 8 7 6 6 6 6 6 6 6 6 6 6 6 6 6 7 8 9
9 8 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 9
9 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9
9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9

Les arguments du patron sont donc ici indiqués entre chevrons après le nom de la classe.

Attention lors de l'imbrication de noms de classes patron : les chevrons doivent être séparés par un caractère d'espacement, sinon ils seront interprétés comme l'opérateur de décalage binaire et la compilation échouera. Par exemple, un vecteur de vecteurs d'entiers doit être déclaré de cette manière :

#include <vector>
std::vector<std::vector<int> > matrix;

Ce problème mineur devrait être résolu dans la prochaine norme du C++, C++1x.

Dans la STL, on en rencontre en particulier avec les conteneurs, comme :

• séquentiels : std::vector, std::deque et std::list ;
• associatifs : std::map et std::set ;

mais aussi dans bien d'autres domaines, tels que :

• les couples de variables : std::pair de <utility> ;
• les nombreux std::basic_* (istream, ostream, string…)…

À chaque fois qu'un patron de classe est utilisé avec de nouveaux arguments, une nouvelle classe patron (attention à bien différencier les deux concepts) est compilée. Ainsi, la déclaration d'un objet de type std::vector<int> et d'un autre de type std::vector<double> instanciera deux classes différentes. Les objets seront donc de types différents, sans qu'aucun lien puisse être fait entre les deux (pas même une conversion).

Le comportement est similaire avec les fonctions : chaque appel d'un patron de fonction avec de nouveaux types d'arguments compile une nouvelle fonction patron.