Faire comme boost::variant

**camboui** · 30/11/2009, 17h49

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** · 30/11/2009, 17h57

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

**Alp** · 30/11/2009, 19h23

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** · 30/11/2009, 22h08

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** · 30/11/2009, 22h54

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** · 01/12/2009, 10h24

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 ?

**Goten** · 01/12/2009, 10h39

Ouaip, ça va jusqu'à 20 types mais c'est extensible via la macro BOOST_VARIANT_LIMIT_TYPES.

Ca fait un moment que j'ai pas regardé comment est géré la liste des templates pour émuler les variadics templates, la dernière fois c'était sur boost.function. Pour boost.function il me semble que c'est vraiment que du prépocesseur, pas des typelist.

NIH = not invented here.

**JulienDuSud** · 01/12/2009, 17h56

Si ton compilo le permet alors utilises les variadic templates et le template recursion plutôt que des macros.

**camboui** · 01/12/2009, 18h32

Comprendre, avais-je dis que je souhaitais comprendre ?
Ça fait 15-20 que les macros C++ existent et je n'arrive pas à comprendre comment faire/simuler une bête boucle. Malgré qu'on dispose des exemples de boost sous les yeux, c'est une telle usine à gaz que j'arrive pas à comprendre comment c'est fait.

Quant aux variadicmachins, encore faut-il les comprendre eux aussi

Mais on verra ça après la release et le premier service pack de VS2010 (l'expérience montre qu'il est prudent d'attendre avec MS

).

**Florian Goo** · 01/12/2009, 23h11

Voici une implémentation de boost::variant avec des templates variadiques. Je pense que c'est beaucoup plus lisible et compréhensible :
http://git.berlios.de/cgi-bin/gitweb...d5df3c43b8e61a

Ensuite, Boost utilise le préprocesseur pour émuler les templates variadiques. Mais l'idée de base est la même.

**Jean-Marc.Bourguet** · 02/12/2009, 08h47

Envoyé par camboui

Comprendre, avais-je dis que je souhaitais comprendre ?
Ça fait 15-20 que les macros C++ existent et je n'arrive pas à comprendre comment faire/simuler une bête boucle. Malgré qu'on dispose des exemples de boost sous les yeux, c'est une telle usine à gaz que j'arrive pas à comprendre comment c'est fait.

Code :

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

1
2
3
4
5
6
7
8
9
10
#define REPEAT1(a, b) b(a)
#define REPEAT2(a, b) b(a)REPEAT1(a,b)
#define REPEAT3(a, b) b(a)REPEAT2(a,b)
 
#define CAT_(a, b) a##b
#define CAT(a,b) CAT_(a, b)
#define REPEAT(n, a, b) CAT(REPEAT,n)(a,b)
 
#define action(a) a+a+a
REPEAT(2, x+y, action)

screetch · 02/12/2009, 09h29

est ce que tu peux expliquer le

Code :

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

1
2
#define CAT_(a, b) a##b
#define CAT(a,b) CAT_(a, b)

?

**camboui** · 02/12/2009, 11h11

Ah voilà qui est plus parlant !

pluzun avec screetch, pourquoi ne pas faire directement #define CAT(a,b) a##b ?

**Jean-Marc.Bourguet** · 02/12/2009, 11h35

C'est pour regler un probleme d'expansion de macro. C'est un grand classique. J'ai pas le temps de donner une explication, mais voir glue et xglue dans les exemples de la norme (que ce soit C ou C++, cet exemple y est) pour ceux qui en dispose.

**Goten** · 02/12/2009, 12h12

Voilà l'exemple de la norme pour ceux qui l'ont pas :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#define HIGHLOW "hello"
#define LOW LOW ", world"
 
#define GLUE(a, b)  a##b
#define xGLUE(a, b) GLUE(a, b)
 
 
GLUE(HIGH, LOW)
xGLUE(HIGH, LOW)

"L'appel" à GLUE va afficher "hello" car il concaténe les deux chaines de caractères HIGH et LOW ce qui donne HIGHLOW et le prépocesseur remplace ça en "hello"

**camboui** · 02/12/2009, 13h27

Cet exemple m'apprend deux choses:
les fonctions sont évaluées avant leurs paramètres;
les paramètres ne sont évalués qu'une fois.

EDIT: ceci ne passe pas:

Code :

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

GLUE( x, GLUE(HIGH,LOW) )

Ce n'est pas convertit en xGLUE(HIGH,LOW) ?

Faire comme boost::variant

C++

Discussions similaires

Partager

Partager