Discussion :

[camboui]

Voici ce que je défini

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
template <typename A1>
struct mastruct
{
	A1 f1;
};
 
template <typename A1,typename A2>
struct mastruct
{
	A1 f1;
	A2 f2;
};

Le compilo n'accepte pas. Pourtant les boost::variant sont parfaitement acceptés.
Comprend pas...

[Goten]

Variant ne fait pas ça... Ils jouent à grand coup de macro pour les paramètres templates mais y'a qu'une seule classe ,)

[Alp]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
template <
      typename T0_
    , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T)
    >
class variant

cf : http://svn.boost.org/svn/boost/trunk...nt/variant.hpp

Faut scroller jusqu'au milieu environ pour tomber sur ça.

[camboui]

J'ai vu le code de boost avec son usage abusif de preproc... sans trop comprendre.
Je pense cependant qu'il y a plusieurs définitions de variant. Il y en a une vingtaine, le fichier include s'incluant lui-même une vingtaine de fois avec à chaque fois un param en plus dans BOOST_VARIANT_ENUM_SHIFTED_PARAMS() (mettez plus de 20 paramètres template dans une instance de variant<> et ça pête).
Mais faisons simple.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
boost::variant<int,std::string> v1;
boost::variant<long,short,char> v2;

Le code qui précède est accepté par les compilos. J'aimerais juste imiter quelque chose de semblable. Vous voyez comment faire, même de manière minimaliste ? Une simple classe qui accepte 1 ou 2 paramètres template sera bien.

[Goten]

Si tu est allergique à toute la machinerie de boost.prepocessor (parce que c'est ça qu'utilise variant derrière) et que tu veux être portable alors tu peux utiliser les typelists.
Pour l'allusion à la portabilité je parle des variadics templates de la prochaine norme :p. (supporté par gcc).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
template<typename T, typename U>
struct Typelist
{
     typedef T head;
     typedef U tail;
};
 
struct NullType {};
 
#define Typelist_1(arg1)  Typelist<arg1, NullType>
#define Typelist_2(arg1, arg2) Typelist<arg1, Typelist_1(arg2)>
....

Et si tu veux éviter du NIH alors tu peux regarder du côté de loki :p

Remarque que si c'est juste pour deux arguments templates alors peut être tu pourrais envisager un truc comme ça ? :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
template <typename T1, typename T2 = NullType>
struct foo { 
//...
};

[camboui]

Je ne souhaite pas faire mais comprendre.
Tu as cependant un peu éclairé ma lanterne, boost fait quelque chose comme ceci avec les variants (il n'utilise pas d'include récursifs comme je le pensais, j'ai confondu avec l'include in_place_factory.hpp).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
struct nulltype {};
 
template <typename A1,typename A2=nulltype,typename A3=nulltype>
struct mastruct
{
 union {
	A1 f1;
	A2 f2;
	A3 f3;
 };
};

boost::variant va jusque typename A20 si j'ai bien vu.

La "machinerie" boost.preproc j'essaie aussi de la comprendre. Je n'arrive pas à faire l'émulation d'un FOREACH.

PS: qu'est-ce NIH ?