[C++] Template et param�tres optionels

Bonjour � tous,

Je me demandais s'il �tait possible de savoir le nombre de param�tre r�ellement pass� � mon constructeur de classe (sans pass� par les va_arg, va_list,... du C) qui a des "template par d�faut" :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <typename T1, typename T2 = void*, typename T3 = void*> class MA_CLASSE { MA_CLASSE(T1 _p1, T2 _p2 = (void*)0, T3 _p3 = (void*)0) : p1(_p1), p2(_p2), p3(_p3) };   // exemples d'appel : MA_CLASSE<int> c1; // un seul paramètre fourni MA_CLASSE<int, float> c2; // 2 params MA_CLASSE<int, flat, int> c3; // 3 paramètres

---

Je sais que ce n'est peut �tre pas tr�s �l�gant de mettre des "void*" en C++ mais je n'ai pas trouv� d'autre solution pour pouvoir instancier ma classe template avec un ou plusieurs types.

Voil�, Merci � vous :)

Salut,

Pour prendre les choses dans l'ordre :

Citation:

---

le nombre de param�tre r�ellement pass� � mon constructeur de classe

---

Utiliser l'overload de constructeur au lieu de param�tre par d�faut ?

Si tu peux utiliser le C++11 tu peux consid�rer les variadic template qui pourraient convenir.

Sinon il y a un probl�me dans ton impl�mentation, quand tu utilises des arguments par d�faut dans le constructeur tu leur affectes une valeur, or tu n'es pas s�re que cette valeur soit correcte en fonction du type. Par exemple je peux appeler ta classe comme �a :

Code:

---

Ma_classe<int, MonType> m(5);

---

Si MonType n'a pas un op�rateur d'affectation prenant un (void*) alors tu auras une erreur de compilation.

Il existe plusieurs solutions pour r�gler ce genre de probl�me mais �a d�pend vraiment du contexte et de la s�mantique de ta classe. Si tu veux un avis qui soit personnalis�, dit nous ce que tu essayes de faire avec ta classe.

Est-ce que tu cherches a avoir un tuple (ou avec boost si tu ne peux pas utiliser le c++11) ?

Salut,

Si tu peux utiliser C++11, tu aurais presque int�r�t � utiliser les variadic template, de mani�re a avoir un nombre d'argument r�ellement variable.

Tu pourrait savoir exactement le nombre d'�l�ment que tu as sous grace � sizeof :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <iostream> template <typename ... Args> struct MyStruct { enum {size = sizeof...(Args)}; }; using NoArgs = MyStruct<>; using OneArg = MyStruct<int>; using TwoArgs = MyStruct<int, std::string>; int main() { std::cout<<"NoArgs has "<<NoArgs::size << " arguments"<<std::endl <<"OneArg has "<<OneArg ::size << " arguments"<<std::endl <<"TwoArgs has "<<TwoArgs ::size << " arguments"<<std::endl; }

---

Avec l'overload du contructeur, ca marche ;)

Je viens de me renseigner sur le variadic template, ca a l'air super puissant ce truc ;) (je ne connaissais pas du tout).

Par contre, comment on fait pour r�cup�rer les types et les valeurs des param�tres vairables ? lol

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

template <typename ... Args> struct MyStruct { enum {size = sizeof...(Args)};   MyStruct() { std::cout << "comment récupérer mes types ?" << std::endl; } };   // et son appel : MyStruct<int, float> toto(5, 10.5);

---

Le but en fait est de cr�er une classe avec des param�tres g�n�riques variables. Donc si je fais par exemple : Param<int, float, double>, je voudrais cr�er une classe avec 3 membres int m_1, float m_2, double m_3
Et si j'appel comme cela : Param<int> alors je n'ai que int m_1 ;)

PS : je n'ai pas trouv� de tr�s bon article sur ce sujet (en fran�ais :P), celui la est assez incompr�hensible :
http://blog.emmanueldeloget.com/inde...es-variadiques

PS 2 : Je n'utilise pas Boost.

Merci :)

Au risque de r�p�ter un peu ce qui a d�j� �t� dit : pour t'aider plus au del�, il faudrait savoir ce que tu cherches � faire avec cette classe. L'exemple de Koala est joli, mais il ne te montre pas ce qu'il y a de plus dur � faire, c'est � dire justement cr�er des variables membres selon les types templates.

Tu as des gens qui ont d�j� pris la peine de le faire, par exemple dans le standard c++11 :

Code:

---

1 2 3 4 5 6 7 8 9

#include <tuple> #include <iostream>   int main() { std::tuple<int, float> toto(5, 10.5); std::cout << "premiere valeur : " << std::get<0>(toto) << std::endl; std::cout << "seconde valeur : " << std::get<1>(toto) << std::endl; return 0; }

---

Plusieurs questions donc :

• est-ce que toutes tes instances de MaClasse doivent avoir 3 variables membres, et tu veux juste pouvoir n'en initialiser que quelques unes ?
• dans le cas contraire, est-ce que tu auras toujours 3 types au maximum, ou est-ce que �a peut changer ?
• et est-ce que tu vas toujours utiliser MaClasse avec de types fixes (ex : int, float, int), ou est-ce que �a peut changer ?
• � quoi �a sert ?

Tiens, l'article d'emmanuel est celui qui m'a permis de comprendre le principe des variadic template :P

Mais, de mani�re g�n�rale, il est vrai que l'on arrive tr�s rapidement � un niveau de complexit� qui n�cessite une maitrise tr�s correcte du paradigme g�n�rique si on veut les utiliser correctement ;)

Parce que, pour faire simple, on pourrait dire que la gestion des arguments pass�s sous la forme d'une liste de template variadiques n�cessite l'appel � la r�cursivit� (mais je te rassure, � la r�cursivit� "compile time" ;))

Je vais, si tu veux bien, et au risque de parler de quelque chose que tu connais d�j�, commencer par parler de la r�cursivit� dans les template "classiques".

Tu as sans doute d�j� aper�u l'article qui parle de la meta programmation et qui indique comment utiliser la sp�cialisation partielle des template pour calculer, une factorielle, par exemple :question:

Si ce n'est pas le cas, et pour t'�viter d'avoir � relire l'article au grand complet (quoi que je ne peux que t'inciter � le faire quand meme :D ),
il faut savoir que le compilateur est capable de "d�rouler des boucle" lorsqu'on lui passe des expressions constantes, et surtout dans le cadre de l'utilisation de template.

Ainsi, nous pourrions tr�s bien demander au compilateur de nous g�n�rer une constante de compilation repr�sentant la factorielle d'un nombre avec un code qui utilise la sp�cialisation partielle (totale, dans le cas pr�sent) et qui serait proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

/* de manière générale, la factorielle d'un nombre est égale à la multiplication  * de ce nombre par la factorielle du nombre -1  */ template <int Value> struct Farctorielle { enum {value = Value * Factorielle<Value-1>::value}; }; /* mais il faut bien arrêter la récursion à un moment donné...  * cela se fait quand on arrive à 0, et la factorielle de 0 donne 1  * (c'est le "cas de base" qu'il faut essayer de gérer comme dans  * toute fonction récursive ;) )  */ template struct Factorielle<0> //spécialisation totale de Factorielle { enum {value = 1}; };

---

Ainsi, lorsque l'on �crira un code proche de

Code:

---

1 2 3 4

int main() { int fact5 = Factorielle<5>::value; }

---

le compilateur r�agira sous une forme proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

int fact5 = 5 * Factorielle<4>::value; /* mince, je dois calculer la factorielle de 4 */ int temp4 = 4 * Factorielle<3>::value; /* mince, je dois calculer la factorielle de 3 */ int temp3 = 3 * Factorielle<2>::value; /* mince, je dois calculer la factorielle de 2 */ int temp2 = 2 * Factorielle<1>::value; /* mince, je dois calculer la factorielle de 1 */ int temp1 = 1 * Factorielle<0>::value; /* mince, je dois calculer la factorielle de 0  * Mais ca, c'est facile... value = 1 */ int temp0 = 1; /* donc temp1 = 1*1 */ temp1 = 1; /* donc temp2 = 2*1 */ temp2 = 2; /* donc temp3 = 3*2 */ temp3 = 6; /* donc temp4 = 4*6 */ temp4 = 24 /* donc fact5 = 5*24 */ fact5 = 120

---

Et, comme il aura suivi tout ce raisonnement au moment de la compilation, il remplacera directement dans le code de main tous ces appels � Factorielle par... la valeur du r�sultat, et cela reviendra exactement au m�me que si on avait �crit

Code:

---

1 2 3 4

int main() { int fact5 = 120; }

---

Une fois que tu as compris cela, le reste devrait finalement �tre beaucoup plus facile � comprendre ;)

La deuxi�me chose dont il faut se souvenir (parce qu'on l'utilise sans arr�t, et je consid�re donc que tu le sais ;) ), c'est que C++ autorise la surcharge de fonctions.

Une surcharge de fonction peut prendre deux formes:

• lorsque le prototype de la fonction accepte le m�me nombre d'arguments, mais il y a au minimum un argument dont le type est diff�rent ou
• si le prototype de la fonction accepte un nombre diff�rent d'arguments

Le premier cas s'applique, par exemple sur les fonctions

Code:

---

1 2	void foo(int ); void foo(std::string const &);

---

et le deuxi�me cas s'applique sur les fonctions

Code:

---

1 2 3

void foo(int); void foo(int, int ); void foo(int, int, int);

---

et donc, il y aura fatalement surcharge avec les fonctions

Code:

---

1 2 3 4 5 6

void foo(int); // (1) void foo(std::string const &); //(2) différent de (1) par le type de l'argument void foo(int, int); //(3) différent de (1) par le nombre d'arguments void foo(std::string const &, int) //(4) différent de (2) par le nombre d'arguments et // différent de (3) parce que le premier argument est de type différent

---

La norme nous dit que, lorsque l'on utilise les variadic template, l'ensemble des types et des valeurs associ�es qui entre dans le cadre de l'�lipse ( les fameux ... ) s'appelle un paramter package.
A d�faut de mieux, nous pouvons sans doute traduire cela par un paquet de param�tres ;) (en fait, je ne sais pas si la communaut� francophone a d�j� trouv� un concensus quant � la traduction de ce terme :aie:)

Et la norme nous dit que le paquet de param�tres va contenir "tout ce qui n'entre pas dans le nombre et le type des arguments explicites".

Cela signifie que si tu as une fonction qui ne prend qu'un paquet de param�tres, sous la forme de

Code:

---

1 2	template <typename ... Args> void foo( Args ... args);

---

et que tu l'appelle sous la forme de

Code:

---

foo<int, int, int, int>(1, 2, 3, 4);

---

le paquet d'arguments sera compos� de quatre int dont les valeurs respectives sont 1, 2, 3 et 4.

Par contre, si tu surcharge la fonction sous la forme de

Code:

---

1 2	template <int, typename ... Args> void foo(int one, Args ... args);

---

comme le compilateur est de nature paresseuse, il choisira la surcharge de la fonction qui lui demande le moins de travail avec le m�me code.

Ainsi, si tu donnes les deux prototypes de fonction au compilateur et que tu �cris le code

Code:

---

foo<int, int, int, int>(1, 2, 3, 4);

---

(qui n'a pas chang� depuis la tantot :D), comme cela demande moins de boulot au compilateur de cr�er un paquet de param�tres contenant trois paires Type / Valeur que d'en cr�er un qui contient quatre paire Type / Valeur, il choisira d'office d'appeler foo(int, Args... args) ;) (on parle en anglais du best match : ce qui correspond le mieux � ce qui est demand� ;))

Mais, pour l'instant, je n'ai pas encore donner de corps � mes diff�rentes surcharges de foo...

Et c'est l� que la r�cursivit� entre en jeu ;)

En effet, si j'impl�mente la surcharge de foo qui prend d�s le d�part un int sous la forme de

Code:

---

1 2 3 4 5 6

template <typename Args...args> void foo(int i, Args...args> { std::cout<<i<<std::endl; // j'utilise i foo(...args); // je rentre dans la récursivité }

---

mon code de la tantot va �tre r�solu sous une forme proche de
appeler foo(int i, Args ... args) avec i = 1 et args = 2, 3, 4

Code:

---

1 2 3 4 5 6 7 8 9

utiliser i appeler foo(int i, Args ... args) avec i = 2 et args = 3,4 utiliser i appeler foo(int i, Args ... args) avec i = 3 et args = 4 utiliser i appeler foo(int i, Args ... args) avec i = 4 et args = rien du tout utiliser i appeler foo... oups, avec rien du tout ==> foo(Args...args) fait l'affaire ;)

---

Enfin, cela fera l'affaire tant que je profite de l'appel � cette fonction pour arr�ter la r�cursivit� avec l'impl�mentation sous la forme de

Code:

---

1 2 3 4 5

template<typename...Args> void foo(Args... args) { std::cout<<"stopping with "<<sizeof...(args)<< " unused arguments"<<std::endl; }

---

Seulement, voil�, j'ai, certes, appel� foo avec un nombre d'argument variable, mais tous les arguments �taient du m�me type :aie:

Or, je peux faire varier le nombre des arguments, mais aussi leur type !!!

Je pourrais tr�s bien d�cider d'�crire un code proche de

Code:

---

1 2 3 4 5 6 7

int main() {   foo<int, int,int, int, std::string const &, int, int >(1, 2, 3, 4,5 , "salut", 6, 7 ); return 0; }

---

Et l�, bien que cela compile sans probl�me, l'ex�cution va m'apporter une lourde d�ception...

Car, en effet, j'aurais un r�sultat proche de

Code:

---

1 2 3 4 5 6

using i = 1, left 7 argument more using i = 2, left 6 argument more using i = 3, left 5 argument more using i = 4, left 4 argument more using i = 5, left 3 argument more stopping with 3 unused arguments

---

Mais bon, c'est normal...

Car apr�s avoir utilis�s les argument 1, 2, 3, 4 et 5, le compilateur se trouve dans une situation o� le seul prototype qui convient pour g�rer "salut",6,7 ben... c'est le prototype tout � fait g�n�rique :aie:

Au moment d'appeler foo("salut",6, 7 ) il va donc appler... foo(Args...args) ;)

Mais bon, je pr�sumes que tu auras trouv� par toi m�me la parade, non :question:

Allez, je vais me faire un caf�, et je te laisse ce temps l� pour y r�fl�chir ;) :java:

Alors, tu as tr�s certainement trouv� la solution, hein :question:

Mais oui, mais c'est bien sur : ajoutons donc une surcharge � foo qui prend une std::string comme argument;)

Sit�t dit, sit�t fait :

Code:

---

1 2 3 4 5 6 7 8

template<typename ... Args> void foo(std::string const & s, Args...args) { std::cout<<"using the "<<s<<" string, left " <<sizeof...(args)<<" argument more"<<std::endl; foo(args...); }

---

Et, "normalement", ca marche...

Note que je vais devoir me renseigner, car il y a peut etre un bug au niveau de gcc dans le sens o�, si j'�cris le code sous la forme de

Code:

---

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 26

template<typename ...Args> void foo(Args ... args) { std::cout<<"stopping with "<<sizeof...(args)<< " unused arguments"<<std::endl; } template<typename ...Args> void foo(int i, Args ... args) { std::cout<<"using i = "<<i <<", left "<<sizeof...(args)<<" argument more"<<std::endl; foo(args...); } template<typename ... Args> void foo(std::string const & s, Args...args) { std::cout<<"using the "<<s<<" string, left " <<sizeof...(args)<<" argument more"<<std::endl; foo(args...); } int main() {   foo<int, int,int, int, std::string , int, int >(1, 2, 3, 4,5 , "salut", 6, 7 ); return 0; }

---

l'ex�cution s'arrete arp�s avoir utilis� 5, alors que si je l'�cris sous la forme de

Code:

---

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 26 27 28 29 30

template<typename ...Args> void foo(int i, Args ... args); template<typename ...Args> void foo(std::string const & s, Args...args); template<typename ...Args> void foo(Args ... args) { std::cout<<"stopping with "<<sizeof...(args)<< " unused arguments"<<std::endl; } template<typename ... Args> void foo(std::string const & s, Args...args) { std::cout<<"using the "<<s<<" string, left " <<sizeof...(args)<<" argument more"<<std::endl; foo(args...); } template<typename ...Args> void foo(int i, Args ... args) { std::cout<<"using i = "<<i <<", left "<<sizeof...(args)<<" argument more"<<std::endl; foo(args...); } int main() {   foo<int, int,int, int, std::string , int, int >(1, 2, 3, 4,5 , "salut", 6, 7 ); return 0; }

---

cela fonctionne correctement :aie:

Enfin bon, en attendant, ceci n'est sans doute qu'un d�tail (ceux qui ont un avis sur la question peuvent y r�pondre ici ;))

Il nous reste un dernier cas qu'il est int�ressant d'envisager...

C'est bien sur celui qui te permet de g�rer "n'importe quel type d'argument", pour autant que tu saches comment tu va le g�rer ;)

H� bien, tu pourrais aussi g�n�raliser le type du premier argument, en partant, par exemple, du principe qu'il existe une surcharge de l'op�rateur << pour le type d'argument que tu voudras passer ;)

La surcharge de foo pourrait alors ressembler �

Code:

---

1 2 3 4 5 6 7

template <typename T, typename ... Args> void foo(T const & t, Args ... args) { std::cout<<"using a generic type "<<t <<", left "<<sizeof...(args)<<" argument more"<<std::endl; foo(args...); }

---

Alors, bien sur, il y a encore beaucoup � dire, mais je crois que je t'ai d�j� donn� une explication qui t'aidera � bien avancer ;)

Ce qui importe, c'est de penser non seulement � la surcharge de fonction, mais aussi � la r�cursivit� (en n'oubliant pas de v�rifier le cas de base, � savoir "yapu d'arguments" :D ) et en n'oubliant pas que tu peux savoir exactement le nombre d'arguments qui se trouve dans le paquet d'arguments en utilisant la syntaxe sizeof ... (nom du paquet)

Salut,

Merci beaucoup pour ton explication !
Tr�s claire et bien d�taill�e ;)
Je vais prendre le temps de d�couvrir ce nouveau paradigme quand j'aurais un peu de temps.

:ccool::ccool: