boucle for métaprog

**CedricMocquillon** · 16/09/2010, 20h38

Bonjour à tous,

Je voudrais à la compilation créer la liste des types formés d'un type de chacune de deux listes:

Code :

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

1
2
3
 
typedef mpl::vector<bool, char> list_types_1;
typedef mpl::vector<short, int, long> list_types_2;

avec comme resultat la liste suivante:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
template<typename T1, T2>
struct Foo {};
 
mpl::vector<
	Foo<bool, short>,
	Foo<bool, int>,
	Foo<bool, long>,
	Foo<char, short>,
	Foo<char, int>,
	Foo<char, long> > list_types_3;

en gros faire une double boucle for :

Code :

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

1
2
3
4
 
foreach type1 in list_types_1
	foreach type2 in list_types_2
		mpl::push_back< list_types_3, Foo<type1, type2> >

mais je vois pas trop comment procéder

(je débute total en métaprog

)

**Goten** · 16/09/2010, 20h49

boost::mpl::joint_view

**CedricMocquillon** · 16/09/2010, 21h02

de ce que j'ai vu de la doc de boost joint_view ce serait plus pour faire un truc du style:

Code :

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

typedef mpl::vector<bool, char, short, int, long> list_types_3;

non?

**Flob90** · 16/09/2010, 21h25

Je ne sais pas ce que propose boost, mais tu peus toujours le refaire toi même, définit proprement l'aglo sur papier (en récursif, plus simple pour la méta-prog je trouve), et code le.

Je te fais un petit exemple qui est un cas réduit du tiens, on suppose une liste de type et un type fixé et on va construire tout les paires entre l'élément et la liste.

Algo:
Cas général, on prend le premier élément de la liste et on fait une pair avec le type fixé, on applique l'algo au reste de la liste, et on mets les deux bout à bout.
Cas terminal, la liste est vide, on retourne une liste vide.

Code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
template<class List, class T> struct do_pair;
 
template<class H, class T, class T>
struct do_pair<TypeList<Head, Tail>, T>
{
    typedef pair<T, Head> NewHead;
    typedef typename do_pair<T, Tail>::Result NewTail;
    typedef TypeList<NewHead, NewTail> Result;
};
 
template<class T>
struct do_pair<NullType, T>
{ typedef NullType Result; };

Edit post message de Joel: J'ai bien dis que je savais pas ce que proposais boost, mais c'etait certain qu'en l'utilisant ca serait mieux qu'un code fait en 2 min sur le forum

J'ai proposé ca pour l'approche algorithme du problème.

**Joel F** · 16/09/2010, 21h54

Y a mieux et plus simple.
C'est un produit cartesien de liste, donc un fold O fold :

Code :

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

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
31
32
 
 
#include <boost/mpl/fold.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/placeholders.hpp>
 
namespace unit
{
  //////////////////////////////////////////////////////////////////////////////
  // meta-cartesian product
  //////////////////////////////////////////////////////////////////////////////
  template<class S1, class S2> struct cartesian_product
  {
    template<class V, class S, class State>
    struct inner
    {
      typedef typename boost::mpl::fold<S
                                       , State
                                       , boost::mpl::push_back< boost::mpl::_1
                                                              , std::pair<V
                                                                         ,boost::mpl::_2
                                                                         >
                                                              >
                                       >::type type;
    };
 
    typedef typename boost::mpl::fold<S1
                                     , boost::mpl::vector<>
                                     , inner<boost::mpl::_2, S2, boost::mpl::_1>
                                     >::type type;
  };

J'ai la flemme mais on peut rempalcer std::pair par un type template façon Foo<_1,_2> et le passer via un apply2

**CedricMocquillon** · 17/09/2010, 20h03

Merci Joel pour ton code, je me suis un peu arraché les cheveux hier pour le comprendre mais finalement après une bonne nuit de sommeil c'est maintenant très clair, je l'ai complété pour qu'il prenne en paramètre une méta-fonction:

Code :

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

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
 
//////////////////////////////////////////////////////////////////////////////
// meta-cartesian product
//////////////////////////////////////////////////////////////////////////////
template<class S1, class S2, class Func > struct cartesian_product
{
	template<class V, class S, class State, class F>
	struct inner
	{
		typedef typename boost::mpl::fold<
				S
				, State
				, boost::mpl::push_back<
					boost::mpl::_1
					, typename boost::mpl::apply<F, V, boost::mpl::_2>::type
					>
				>::type type;
	};
 
	typedef typename boost::mpl::fold<
			S1
			, boost::mpl::vector<>
			, inner<boost::mpl::_2, S2, boost::mpl::_1, Func>
			>::type type;
};

avec le test suivant:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
struct MyFunction
{
	template<typename T1, typename T2>
	struct apply
	{
		typedef Foo<T1, T2> type;
	};
};
 
typedef boost::mpl::vector<bool, char> v1;
typedef boost::mpl::vector<short, int> v2;
 
typedef cartesian_product<v1, v2, MyFunction>::type result;
 
BOOST_MPL_ASSERT(( boost::is_same< boost::mpl::at_c<result, 0>::type, Foo<bool, short> >));
BOOST_MPL_ASSERT(( boost::is_same< boost::mpl::at_c<result, 1>::type, Foo<bool, int> >));
BOOST_MPL_ASSERT(( boost::is_same< boost::mpl::at_c<result, 2>::type, Foo<char, short> >));
BOOST_MPL_ASSERT(( boost::is_same< boost::mpl::at_c<result, 3>::type, Foo<char, char> >)); //ici problème de compilation: Foo<char, char> != Foo<char, int>

Par contre j'ai plusieurs questions:
(1) Est-il possible de comparer directement result avec un mpl::vector< Foo<bool, short>, Foo<bool, int>, Foo<char, short>, Foo<char, int> >
(2) Peut-on se passer d'écrire la méta-fonction MyFunction (en faisant un truc du genre des lambda: une méta-fonction non nommée qu'on utiliserai directement lors de typedef cartesian_product<v1, v2, MyFunction>::type result)

**Goten** · 17/09/2010, 20h09

Envoyé par CedricMocquillon

de ce que j'ai vu de la doc de boost joint_view ce serait plus pour faire un truc du style:

Code :

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

typedef mpl::vector<bool, char, short, int, long> list_types_3;

non?

Désolé j'avais mal lu l'énoncé, (ça m'apprendra a poster quand j'en ai pas le temps).

(1) : boost::mpl::equal

(2) : A première vu oui mais j'ai pas le temps (encore...) de pondre un code là.

**Joel F** · 17/09/2010, 20h35

Envoyé par CedricMocquillon

(2) Peut-on se passer d'écrire la méta-fonction MyFunction (en faisant un truc du genre des lambda: une méta-fonction non nommée qu'on utiliserai directement lors de typedef cartesian_product<v1, v2, MyFunction>::type result)

Oui, attention c'est du lourd:

n'importe quelle classe template ou apparait un _n en parametre devient une lambda.

Code :

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

1
2
 
typedef cartesian_product<v1, v2, Foo<boost::mpl::_1, boost::mpl::_2> >::type result;

**CedricMocquillon** · 17/09/2010, 21h06

Grande classe! Merci à tous pour votre aide

**Goten** · 17/09/2010, 21h11

Envoyé par Joel F

Oui, attention c'est du lourd:

n'importe quelle classe template ou apparait un _n en parametre devient une lambda.

Code :

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

1
2
 
typedef cartesian_product<v1, v2, Foo<boost::mpl::_1, boost::mpl::_2> >::type result;

Ok, j'avais encore pas du tout regardé le bon code...

bon faut que j'aille dormir moi...

*hey tyler, ça marche les savons* ?

**guillaume07** · 18/09/2010, 16h37

et ça peut avoir un intérêt ce code lol ?

**Flob90** · 18/09/2010, 17h07

Envoyé par guillaume07

et ça peut avoir un intérêt ce code lol ?

Tu comptes demander si la méta-prog à un interet à chaque fois que tu vois un exemple ?

Construire toute les paires possibles d'éléments d'une liste de types pourrait par exemple avoir une utilité pour résoudre du multi-dispatch. Et surment plien d'autre exemple.

**guillaume07** · 18/09/2010, 17h22

à chaque fois que je n'en verrais pas un intérêt direct oui tant pis si tu m'aimes pas

**Flob90** · 18/09/2010, 18h01

D'accord, je vais essayer d'apporter une réponse plus complète alors

La méta-prog n'est pas en soi essentiel, mais elle apporte une généricité plus grande qui peut se révéler très utile.

Si tu as le temps, écris un code qui doit visiter une hiérachie : visiteur ou multi-methodes par exemple, une fois normalement, une fois avec de la méta-prog, puis modifie chacun de tes codes pour rajouter une classe dans la hiérarchie, tu devrais sentir l'utilité.

Mais la TMP est un langage en soi, dont le code est executé directement par le compilateur. En tant que langage, tout problème que tu peus te poser en C++ (classique) peut avoir lieux d'être en TMP.

Dans le cas de l'OP c'est donc se demander quel est l'utilité de contruire un vecteur de paires, à partir d'une vecteur, qui contient toute les pairs possibles du premier vecteur. Et sans exemples je suis presque certain que tu en concois que ca peut servir. C'est pareil en TMP.

Mathématiquement, comme l'a souligné Joel, c'est un produit cartésien d'un ensemble finie par lui-même. Donc en C++ (classique) comme en TMP, ca peut servir dans un porgramme mathématique pour représenter un ensemble de type E² (avec E finie), et par extension à tout algorithme mathématique qui se ramène à un problème mathématique basé sur E².

**guillaume07** · 18/09/2010, 18h10

ok merci j'essayerais l'histoire du visteur

boucle for métaprog

C++

Discussions similaires

Partager

Partager