Rechercher
 
Notre page Facebook
Notre groupe Facebook


Android Game
Line Phaser - Android Game

Les nouveautés C++ 2011 relatives à l'utilisation de templates

Avec le nouveau C++ ISO 2011, des évolutions font leur apparition pour la définition des templates. Voici un petit résumé de ces nouveautés.

Définition d'un type template basé sur un autre type template.

Anciennement, si vous définissiez un type template à partir d'un autre type template, vous deviez faire attention à ne pas produire deux caractères > consécutivement, sinon le compilateur ne comprenait pas ce que faisait l'opérateur >> dans la définition du type. Deux solutions était possibles pour régler ce problème : ajouter un espace ou utiliser un typedef.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
#include <vector>

// Solution 1

std::vector< std::vector<int> > matrix;
                        //   ^ white space is mandatory before C++ ISO 2011

// Solution 2

typedef std::vector<int> int_vector;
std::vector<int_vector> matrix2;
Avant C++ ISO 2011

Il est maintenant possible de ne plus se soucier de ce point de détail et de coller vos deux caractères >. C'est plus simple.

 1 
 2 
 3 
 4 
 5 
#include <vector>


std::vector<std::vector<int>> matrix;
                        //  ^ no white space is required with C++ ISO 2011
Après C++ ISO 2011

Les templates variadiques

Il vous est maintenant possible de définir des fonctions génériques (templates) avec un nombre variable de types génériques.

 1 
 2 
 3 
 4 
template <typename T, typename ... ARGS>
void method( const T & parameter, const ARGS & ... args ) {
    // TODO
}
Syntaxe pour déclarer un template variadique

En fait, il est nécessaire de mettre en oeuvre de la spécialisation de template pour coder un template variadique. Voici un exemple qui permet d'afficher un nombre quelconque de paramètres (chacun d'eux pouvant avoir un type spécifique).

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
#include <iostream>
#include <string>

using namespace std;


template <typename T>
void display( const T & parameter ) {
    cout << parameter << endl;
}


template <typename T, typename ... ARGS>
void display( const T & parameter, const ARGS & ... args ) {
    cout << parameter << " ";
    display( args... );
}


int main() {

    display( "Hello", 1, string("value"), 4.3 );

    return 0;
}
Exemple de mise en oeuvre d'un template variadique

Après résolution par le compilateur, quatre fonctions auront été générées par cet exemple. La spécialisation à nombre variable de paramètre ayant produit les surcharges suivante : void display( const char *, int, string, double ), void display( const int &, string, double ) et void display( const string &, double ). L'autre spécialisation produit une seul surcharge : void display( const double & ). Pour compiler et exécuter votre programme, veuillez procéder ainsi :

$> g++ -std=c++11 -o Essai Essai.cpp 
$> Essai
Hello 1 value 4.3
$>

Les templates externes

 1 
extern template class std::vector<MyType>;
les templates externes