Variadic templates

Variadic templates sont une partie du C++0x standard qui n'est pas encore officiellement sorti. Ils sont pris en charge par la gcc depuis la version 4.3, mais vous devez activer le support de C++0x en ajoutant le commutateur de compilateur -std=c++0x.

OriginalL'auteur David Feurle

Variadic templates sont une C++0x fonctionnalité qui cible principalement les auteurs du générique de bibliothèques. Je ne m'attends pas à les voir dans le "code d'utilisateur". Par exemple, dans le C++0x bibliothèque standard, ils sont utilisés dans beaucoup d'endroits: std::function, std::asynchrone, std::reference_wrapper, std::tuple, std::packaged_task, ...

Pour vous donner un exemple, je vais vous montrer comment un reference_wrapper pourrait être mise en œuvre à l'égard de variadic templates:

template<class T>
class reference_wrapper
{
    T *ptr;
public:
    explicit reference_wrapper(T& thing) : ptr(&thing) {}
    explicit reference_wrapper(T&&     ) = delete;

    operator T&() const {return *ptr;}

    template<class... Args>
    decltype( declval<T&>()(declval<Args>()...) )
    operator()(Args&&... args) const
    {
        return (*ptr)(forward<Args>(args)...);
    }
};

Ce n'est pas parfaitement conforme au projet de norme, mais il est censé être compilable avec peu de modifications. Il démontre plusieurs C++0x caractéristiques:

• supprimé fonctions (désactivation du constructeur pour les rvalues)
• références rvalue (détection de rvalue arguments du constructeur, le transfert parfait)
• type de déduction via decltype
• de la bibliothèque standard modèle de fonction declval de créer des objets dans le but de construire une expression pour decltype (GCC n'offre pas encore ce modèle de fonction. Vous devez écrire vous-même)
• variadic templates (accepter un nombre arbitraire de paramètres)

Le but de la variadic membre de modèle est d'avancer des arguments à l'objet visé par ptr. Cela devrait fonctionner dans le cas où T est un pointeur de fonction type ou d'un type de classe avec fonction surchargée d'appel de l'opérateur.

cheers!
s

OriginalL'auteur sellibitze

Un exemple très simple de variadic template:

Supposons que nous voulons avoir une fonction qui prend un nombre variable d'arguments et de les imprimer tous. Ex:

print("Hello", 1, 3.14, 5L);

Pour que cette fonctionnalité fonctionne, il serait fondamentalement besoin de deux fonctions:

Première, une fonction qui prend un nombre variable d'arguments:

template<typename T, typename... Args>
void print(T t, Args ...args){
     std::cout << t << ", ";
     print(args...);
}

Quelques explications:

1.) Paramètre Packs indiqué par des points de suspension(...), qui apparaissent dans la liste des paramètres.

typename...Args 
        |  | << Optional whitespace. Can have multiple whitespaces in between them
    Args...args

Cela signifie que, ces tous sont les mêmes.

typename ...args
typename...args
typename   ...   args

Donc, vous n'avez pas à vous soucier de la position correcte de l'espace. Cependant, l'OMI, au plus les espaces doivent être utilisés en tant que meilleure pratique.

2.) Pack d'Extension: Une tendance suivie par des points de suspension.

print(args...); //expand when you wish to use them

3.) Paramètre pack accepte zéro ou plus modèle args. Donc, print(T t, Args... args) accepte un ou plusieurs args.

---

Une fois que vous comprenez que, nous pouvons visualiser le flux d'appels en tant que ci-dessous:

print("Hello", 1, 3.14, 5L);

se traduit par:

print(string, int, float, long);

qui appelle

print(int, float, long);

qui appelle

print(float, long);  //say Level 2

qui appelle

print(long);         //say Level 1

qui appelle

print();             //say Level 0

Si vous avez suivi le Point#3 avec soin, vous devez avoir réalisé que print(T t, Args... args) ne peut pas gérer l'appel au Niveau 0.

Nous avons donc besoin d'une autre fonction ici avec le même nom de le rattraper à n'importe quel niveau >=0.

---

Second, une fonction de saisir à l'appel du haut de la pile des appels:

Attraper au niveau 0:

void print(){}

ou, Attraper au niveau 1:

template<typename T>
void print(T t){ std::cout << t;}

ou, Attraper au niveau 2:

template<typename T, typename U>
void print(T t, U u){ std::cout << t << ", " << u;}

etc...

Aucun de ces travaux. Espérons que cela aide à vous la prochaine fois que vous allez au sujet de l'écriture de cette fonction ou de la classe.

OriginalL'auteur Saurav Sahu

Avant C++11, vous pouvez créer un modèle uniquement avec le fixe nombre de paramètres.

Évolution du modèle de la fonction avec un paramètre.

Deuxième modèle pour la fonction à deux paramètres.
... c'est à dire

Depuis C++11, vous pouvez écrire un seul modèle, le compilateur va générer, conformément à la fonction elle-même.

Bon exemple
http://eli.thegreenplace.net/2014/variadic-templates-in-c/

OriginalL'auteur Sergey