Discussion :

[CedricMocquillon]

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]

boost::mpl::joint_view

[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?

[Flob90]

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]

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]

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]

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à.