^ Chapitre précédent ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ Chapitre suivant ^

====== [Aller plus loin] Les classes et fonctions variadiques ======

http://en.cppreference.com/w/cpp/language/parameter_pack et http://en.cppreference.com/w/cpp/language/sizeof...

===== Fonctions avec nombre de paramètres non fixés =====

Permet d'écrire une fonction avec un nombre variable de paramètres de fonction. Exemple simple : on veut afficher un tableau avec des variables. Première approche, avec fonctions classiques et paramètre par défaut :

<code cpp>
void print_array (int a, int b = 0, int c = 0, int d = 0) {
    std::cout << a << '\t' << b << '\t' << c << '\t' << d << '\n';
}


// ou avec surcharge de fonction
void print_array (int a) {
    std::cout << a << '\n';
}

void print_array (int a, int b) {
    std::cout << a << '\t' << b << '\n';
}

void print_array (int a, int b, int c) {
    std::cout << a << '\t' << b << '\t' << c << '\n';
}

void print_array (int a, int b, int c, int d) {
    std::cout << a << '\t' << b << '\t' << c << '\t' << d << '\n';
}
</code>

La première affiche toujours 4 colonnes (remplit avec des 0 si nécessaire). La seconde évite les 0 inutiles, mais nécessite d'écrire une fonction pour chaque possibilité.

Améliorable pour ne pas prendre que des int :

<code cpp>
template<class A>
void print_array (A a) {
    std::cout << a << '\n';
}

template<class A, class B>
void print_array (A a, B b) {
    std::cout << a << '\t' << b << '\n';
}

template<class A, class B, class C>
void print_array (A a, B b, C c) {
    std::cout << a << '\t' << b << '\t' << c << '\n';
}

template<class A, class B, class C, class D>
void print_array (A a, B b, C c, D d) {
    std::cout << a << '\t' << b << '\t' << c << '\t' << d << '\n';
}
</code>

Très lourd à écrire, nombre maximal de paramètres fixés

===== Les fonctions variadiques =====

Possibilité d'indiquer qu'une fonction prend un nombre indéterminé de paramètres. A la compilation, le compilateur déterminer lui même le nombre de paramètre.

Comme on ne connaît pas le nombre de paramètres, le plus simple est d'utiliser une fonction récursive, avec une condition d'arrêt. L'idée est que l'on définie une fonction qui prend N paramètres et utilise la fonction N-1 paramètres (fonction récursive) et une fonction qui prend 1 paramètre et s'appelle pas de fonction N (condition d'arrêt).

En pseudo code :

<code>
f(N paramètres) {
    appel de f(N-1 paramètres)
}

f(1 paramètre) {
}
</code>

Si on appelle ce code avec 5 paramètres par exemple, le code précédent est "déroulé" (ie convertie en une suite de fonctions non récursives) de la façon suivante :

<code>
f(5 paramètres) {
    appel de f(4 paramètres)
}

f(4 paramètres) {
    appel de f(3 paramètres)
}

f(3 paramètres) {
    appel de f(2 paramètres)
}

f(2 paramètres) {
    appel de f(1 paramètre)
}

f(1 paramètre) {
}
</code>

On voit que chaque fonction appelle la fonction N-1 sauf pour N=2, qui appelle la fonction déjà définie f1.

==== Syntaxe ====

Utilisation de ''...'' dans la liste des paramètres template et la liste des paramètres de fonction. 

<code cpp>
template<class ... T>
void f(T ... values) {
}
</code>


Appel récursif : extraire le premier paramètre et les autres paramètres, appel récursif sur les autres paramètres.

<code cpp>
template<class T>
void f(T value) {                    // condition d'arrêt
}

template<class T, class ...Args>
void f(T value, Args ... args) {
    f(args);                         // appel récursif
}
</code>

Avec le code de print_array :

<code cpp>
#include <iostream>

template<class T>
void print_array (T value) {
    std::cout << value << '\n';   // affichage du dernier élément
}

template<class T, class ...Args>
void print_array (T value, Args ... args) {
    std::cout << value << '\t';   // affichage de l'élément courant
    print_array(args...);            // affichage des autres éléments
}

int main() {
    print_array(1, 2, 3);
    print_array(1.2, "hello", 2.3, "world");
}
</code>

<note>Template spécialisation ?</note>

==== Classes template variadiques ====

Idem, avec des classes. 

<code cpp>
template<class ... Args>
struct A {
    std::tuple<Args...> args;
};
</code>
    
==== Exercices ====

  * réécrire std::tuple
  * écrire make_tuple

^ Chapitre précédent ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ Chapitre suivant ^

{{tag> Cours C++}}