membres en fonction d'un template

Version imprimable

J'ai encore une autre question sur les templates qui me travaille depuis un certain temps: est-ce qu'il est possible de faire un "branchement" selon un paramètre de template ?

Par exemple, du genre suivant: (code qui ne compilera pas)
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 template<typename _T, int _sizeT> struct vec_proto { union { _T a[_sizeT]; struct { _T x; ##if(_sizeT >= 2) _T y; ##if(_sizeT >= 3) _T z; ##if(_sizeT >= 4) _T w; ##if(_sizeT > 4) #pragma error; ##endif ##endif ##endif ##endif }; }; };

Salut,

Bon déjà là ça rentre dans le cadre de la métaprogrammation (pour des solutions "automatisées").
Tu trouveras de quoi te satisfaire sur le sujet (niveau lecture + outils) dans l'article de Laurent (http://loulou.developpez.com/tutoriels/cpp/metaprog/) et dans Boost.MPL (http://www.boost.org/doc/libs/1_35_0...doc/index.html).

Toutefois, la solution la plus facile à mettre en place dans ton cas, c'est de spécialiser selon la valeur de sizeT.
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 template<typename _T, int _sizeT> struct vec_proto { union { _T a[_sizeT]; struct { _T x; }; }; }; template <typename _T> struct vec_proto<_T, 2> { union { _T a[2]; struct { _T x; _T y; }; }; }; // etc...
Et pour générer les spécialisations automatiquement, regarde du côté de Boost.Preprocessor (http://www.boost.org/doc/libs/1_35_0...doc/index.html).

Je connais assez mal la méta-programmation, mais ton problème m'a donné envie de m'amuser un peu, voilà ce qui en est ressorti :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
//Permet de créer une structure contenant N attributs nommés x1..xN
 
template<int a, int b>
struct sub
{
    static const int res = a - b;
};
 
template<typename T, int N>
struct attr
{
};
 
#define ATTR(n)                                     \
 template<typename T>                               \
 struct attr<T, n> : public attr<T, sub<n, 1>::res> \
 {                                                  \
     T x##n;                                        \
 }
 
ATTR(1);
ATTR(2);
ATTR(3);
ATTR(4);
 
int main()
{
    attr<int, 1> a;
 
    a.x1;
    //a.x2 --> erreur de compilation
 
    attr<int, 2> b;
 
    b.x1;
    b.x2; // --> ok
 
    attr<int, 5> notok; // malheureusement, cela passe à la compil
 
    //notok.x1; --> si on essaye d'atteindre un attribut, erreur de compil
 
    return 0;
}

Je n'ai pas mis le tableau, mais je ne pense que cela pose trop de problèmes.

Tu te complique la vie avec ta structure sub.

Code:

1
2
3
4
 
//...
struct attr<T, n> : public attr<T,n-1>		    \
//....

passe tout aussi bien.

Edit:
Ce code empèche att<int,5> de compiler

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
31
32
 
template<typename T, int N> struct attr;
template <typename T> struct attr<T,0>{};
 
#define ATTR(n)                                     \
 template<typename T>                               \
 struct attr<T, n> : public attr<T,n-1>		    \
 {                                                  \
     T x##n;                                        \
 }
 
ATTR(1);
ATTR(2);
ATTR(3);
ATTR(4);
 
int main()
{
    attr<int, 1> a;
 
    a.x1;
    //a.x2 --> erreur de compilation
 
    attr<int, 2> b;
 
    b.x1;
    b.x2; // --> ok
 
    attr<int, 5> notok; //passe plus
 
    return 0;
}

Pour empêcher d'instancier à plus de 4 et moins de 1, on peut utiliser un static assert, ceux de boost pour le moment par exemple :

Code:

1
2
3
4
5
6
7
#define ATTR(n)                                     \
 template<typename T>                               \
 struct attr<T, n> : public attr<T, n-1> \
 {                      
     BOOST_STATIC_ASSERT(n > 0 && n < 5)       \
     T x##n;                                                   \
 }

14/08/2008, 15h39
stillman
Citation:
Envoyé par Davidbrcz

Tu te complique la vie avec ta structure sub.

Code:

1 2 3 4 //... struct attr<T, n> : public attr<T,n-1> \ //....

passe tout aussi bien.
Tout à fait, c'est une complication totalement inutile :oops: ! Je l'ai mise en oeuvre en me disant que le préprocesseur ne ferait pas le calcul et remplaçerait le code par attr<T, 1 - 1> au lieu de attr<T, 0>...mais ça n'a aucune raison de gêner le compilo ! J'ai le cerveau qui tourne au ralenti...

j'ai l'impression que ce que je veux générer pourrait se faire via BOOST_PP_ARRAY_DATA(a), mais je n'ai pas vraiment compris l'exmple. (Bon,il fait tard après une semaine lourde en boulot, donc...)

edit: merci pour les idées, j'ai écrit un petit bout de code:
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 31 32 33 34 35 36 37 38 39 template<typename T> struct math { class vec2; class vec3; class vec4; }; template<typename T, int sizeT> struct t_vec; template<typename T>struct t_vec<T, 2>{ T x; T y; }; template<typename T>struct t_vec<T, 3>{ T x; T y; T z; }; template<typename T>struct t_vec<T, 4>{ T x; T y; T z; T w; }; template<typename T, int sizeT> union tunion { T a[sizeT]; t_vec<T, sizeT> v; }; template<typename T> struct math<T>::vec2 { tunion<T, 2> u; }; template<typename T> struct math<T>::vec3 { tunion<T, 3> u; }; template<typename T> struct math<T>::vec4 { tunion<T, 4> u; };
pour l'instance du tout:
Code:

1 2 3 math<float>::vec2 fv2; fv2.u.v.x = 1.0f; fv2.u.v.y = 2.0f;
le poblème, c'est que ce u.v.x ... c'est un peu lourdingue. Il y a mieux, je suppose. Des idées?

15/08/2008, 23h52
Alp

Citation:

Envoyé par Kurisu

j'ai l'impression que ce que je veux générer pourrait se faire via BOOST_PP_ARRAY_DATA(a), mais je n'ai pas vraiment compris l'exmple. (Bon,il fait tard après une semaine lourde en boulot, donc...)

C'est sur cette piste là que je voulais te mettre, effectivement ;)
Boost.PP te permettra de faire ce que tu souhaites aussi. Mais la technique donnée plus tôt est très bonne aussi.

En regardant un peu la doc, je suis arrivé à un truc comme le suivant...
je testerai ca plus tard en tout cas.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #define VNAME (x, y, z, w) #define CNAME (r, g, b, a) #define NNAME (_0, _1, _2, _3) template<typename T, int sizeT> union UU { T a[sizeT]; struct{ T BOOST_PP_ARRAY_DATA(sizeT, VNAME); }; struct{ T BOOST_PP_ARRAY_DATA(sizeT, CNAME); }; struct{ T BOOST_PP_ARRAY_DATA(sizeT, NNAME); }; };
Est-ce la bonne direction?

19/08/2008, 01h08
Kurisu

en fait, en regardant ca de plus de près, c'est le chemin inverse, c'est-à-dire, générer la concretisation du template avec le preprocesseur. C'est vicieux et pervers, mais ca me plaît comme direction. :mouarf:
Update demain, une fois que j'aurais testé un peu mon idée.

Bon, actuellement, j'ai écrit un petit bout de code qui ressemble plus à de la magie noire qu'à du C++. J'ai pas encore compilé (car pas de boost sur Wii et la flemme de l'installer pour VC2005 (je suis au boulot)), mais voici le code:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/comparison/not_equal.hpp>
#include <boost/preprocessor/repetition/for.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
 
 
 
namespace kazu
{
	template<typename typeT> 
	typedef typeT scalar;
	struct blast
	{
		class vec2;
		class vec3;
		class vec4;
	};
} //namespace kazu
 
template<typename typeT, int sizeT>
struct vec_struct;
 
#define	STRUCT_SIZE_ASSERT(x)	BOOST_STATIC_ASSERT(1 < x && x <= 4)
#define	VEC_POSITION_ARRAY		(x, y, z, w)
#define VEC_NUM_ARRAY			(_0, _1, _2, _3)
#define	VEC_TEXCOORD_ARRAY		(s, t, u, v)
#define	VEC_COLOR_ARRAY4		(r, g, b, a)
#define VEC_COLOR_ARRAY2		(i, a)
 
#define	GEN_SIMPLE_VEC_ELEM(index, array)				\
		BOOST_PP_ARRAY_ELEM(index, array)				\
 
#define	GEN_COLOR_VEC_ELEM()
 
 
#define FOR_END_PREDICATE(r, state)							\
		BOOST_PP_NOT_EQUAL(									\
			BOOST_PP_TUPLE_ELEM(2, 0, state),				\
			BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2, 1, state))	\
		)													\
 
 
#define FOR_INCREMENT_OP(r, state)							\
		(													\
			BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2, 0, state)),	\
			BOOST_PP_TUPLE_ELEM(2, 1, state) 				\
		)													\
 
 
#define	FOR_GEN_SIMPLE_MACRO(r, state)						\
		GEN_SIMPLE_VEC_ELEM(								\
			BOOST_PP_TUPLE_ELEM(2, 0, state),				\
			array)											\
 
 
#define	GEN_SIMLE_VEC(type, size, array)					\
		BOOST_PP_FOR(										\
			(0, size),										\
			FOR_END_PREDICATE,								\
			FOR_INCREMENT_OP,								\
			FOR_GEN_SIMPLE_MACRO)							\
 
 
#define	VEC_MEMBER_TPL_GEN(size)												\
		template<typename typeT>												\
		struct vec_struct<typeT, size>		{									\		
			STRUCT_SIZE_ASSERT(size);											\
			union		{														\			
				typeT	_a[size];												\
				struct	{	GEN_SIMPLE_VEC(typeT, size, VEC_POSITION_ARRAY)	};	\
				struct	{	GEN_SIMPLE_VEC(typeT, size, VEC_NUM_ARRAY)		};	\
				struct	{	GEN_SIMPLE_VEC(typeT, size, VEC_TEXCOORD_ARRAY)	};	\
//				struct	{	GEN_COLOR_VEC(typeT, size, VEC_COLOR_ARRAY)		};	\
			};																	\				
		}																		\
			
VEC_MEMBER_TPL_GEN(2);
VEC_MEMBER_TPL_GEN(3);
VEC_MEMBER_TPL_GEN(4);
VEC_MEMBER_TPL_GEN(1);	//error
VEC_MEMBER_TPL_GEN(5);	//error
 
#define	VEC_STRUCT_CONCRETE(type, size)						\
		class kazu::blast<type>::vec##size		:			\
		public vec_struct<kazu::blast<type>::scalar, size>
 
template<typename typeT>
VEC_STRUCT_CONCRETE(typeT, 2)
{
};
 
template<typename typeT>
VEC_STRUCT_CONCRETE(typeT, 3)
{
};
 
template<typename typeT>
VEC_STRUCT_CONCRETE(typeT, 4)
{
};

:aie:
Est-ce qu'il y a un petit tool qui permet de voir le code que le préprocesseur me génère, histoire de pouvoir debugger.

Puis, j'ai pas vraiment compris à quoi sert le "r" dans le FOR: cf.: http://www.boost.org/doc/libs/1_35_0...c/ref/for.html

20/08/2008, 21h37
Davidbrcz

Citation:

Est-ce qu'il y a un petit tool qui permet de voir le code que le préprocesseur me génère, histoire de pouvoir debugger.

option -E de g++
Mais attention, ca va aussi t'afficher les includes, ce qui fait au final pas mal de texte.

Citation:

Envoyé par Davidbrcz

option -E de g++
Mais attention, ca va aussi t'afficher les includes, ce qui fait au final pas mal de texte.

merci, j'avais déjà trouvé ca sur le web 10 minutes avant ta réponse.
D'ailleurs XCode propose directement l'option "Preprocess".
Avec MSVC, ce sont les paramètres /E, /P ou /EP (et /C pour laisser les commentaires) qui perment de l'obtenir. /P va générer le fameux fichier .i du preprocesseur.

Actuellement, je suis en train de debugger le code prepro en suivant les exemples:
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 #define PRED(r, state) \ BOOST_PP_NOT_EQUAL( \ BOOST_PP_TUPLE_ELEM(2, 0, state), \ BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2, 1, state)) \ ) \ /**/ #define OP(r, state) \ ( \ BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2, 0, state)), \ BOOST_PP_TUPLE_ELEM(2, 1, state) \ ) \ /**/ #define MACRO(r, state) BOOST_PP_TUPLE_ELEM(2, 0, state) #define STRING #BOOST_PP_FOR((5, 10), PRED, OP, MACRO) // expands to 5 6 7 8 9 10 void test_orig() { std::cout << STRING << std::endl; } #define TEST_ARRAY (10, (a, b, c, d, e, f, g, h, i, j)) #define MACRO_ARRAY(r, state) BOOST_PP_ARRAY_ELEM( BOOST_PP_TUPLE_ELEM(2, 0, state), TEST_ARRAY) BOOST_PP_FOR((0, 6), PRED, OP, MACRO_ARRAY) //expands to a b c d e f

ca avance, ca avance :D

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
 
#define	STRUCT_SIZE_ASSERT(x)	BOOST_STATIC_ASSERT(1 < x && x <= 4)
#define	VEC_POSITION_ARRAY		(4, (x, y, z, w))
#define VEC_NUM_ARRAY			(4, (_0, _1, _2, _3))
#define	VEC_TEXCOORD_ARRAY		(4, (s, t, u, v))
#define	VEC_COLOR_ARRAY4		(4, (r, g, b, a))
#define VEC_COLOR_ARRAY2		(2, (i, a))
 
#define	GEN_STRUCT_REP_MACRO(z, n, param)						\
	BOOST_PP_TUPLE_ELEM(2, 0, param)							\
	BOOST_PP_ARRAY_ELEM(n, BOOST_PP_TUPLE_ELEM(2, 1, param));	\
//resolves to type array(n);
 
#define GEN_STRUCT(type, size, array)					\
		struct {										\
			BOOST_PP_REPEAT_FROM_TO(					\
				0,										\
				size,									\
				GEN_STRUCT_REP_MACRO,					\
				(type, array)							\
			)											\
		}												\
 
//resolves to struct { type array(0); ... };
 
GEN_STRUCT(float, 3, VEC_POSITION_ARRAY);	//resolves to struct { float x; float y; float z; };

le code final plus tard.

ca y est, fini.
merci encore à Alp pour m'avoir mis sur la voie de Boost.Preprocessor (et de m'avoir mis la puce à l'oreille). 8-)

le code (avec un peu de chance, les \\ se feront pas bouffer):

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
//!     \file   boostpp_test.cpp
//!     @brief  testing boost pp
 
#include <boost/static_assert.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/comparison/not_equal.hpp>
#include <boost/preprocessor/repetition/for.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/array/elem.hpp>
#include <boost/preprocessor/array/size.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/preprocessor/comparison/equal.hpp>
 
 
namespace kazu
{
	template<typename typeT> 
	struct blast
	{
		typedef typeT scalar;
 
		class vec2;
		class vec3;
		class vec4;
	};
} //namespace kazu
 
template<typename typeT, int sizeT>
struct vec_struct;
 
//---------------------------------------------------------------------------
 
#define	STRUCT_SIZE_ASSERT(x)	BOOST_STATIC_ASSERT(1 < x && x <= 4)
#define	VEC_POSITION_ARRAY		(4, (x, y, z, w))
#define VEC_NUM_ARRAY			(4, (_0, _1, _2, _3))
#define	VEC_TEXCOORD_ARRAY		(4, (s, t, u, v))
#define	VEC_COLOR_ARRAY4		(4, (r, g, b, a))
#define VEC_COLOR_ARRAY2		(2, (i, a))
 
#define ELEMENT_ARRAYS			(3, (VEC_POSITION_ARRAY, VEC_NUM_ARRAY, VEC_TEXCOORD_ARRAY))
#define COLOR_ARRAYS			(VEC_COLOR_ARRAY2, VEC_COLOR_ARRAY4)
 
//---------------------------------------------------------------------------
 
 
#define	GEN_STRUCT_REP_MACRO(z, n, param)						\
	BOOST_PP_TUPLE_ELEM(2, 0, param)							\
	BOOST_PP_ARRAY_ELEM(n, BOOST_PP_TUPLE_ELEM(2, 1, param));	\
//resolves to type array(n);
 
#define GEN_STRUCT(type, size, array)	\
		struct {						\
			BOOST_PP_REPEAT_FROM_TO(	\
				0,						\
				size,					\
				GEN_STRUCT_REP_MACRO,	\
				(type, array)			\
			)							\
		}								\
//resolves to struct { type array(0); ... };
 
GEN_STRUCT(float, 3, VEC_POSITION_ARRAY);	//resolves to struct { float x; float y; float z; };
 
//---------------------------------------------------------------------------
 
#define GEN_COLOR_STRUCT(type, size, colors)		\
		BOOST_PP_IIF(								\
			BOOST_PP_EQUAL(size, 2),				\
			GEN_STRUCT(type, size,					\
				BOOST_PP_TUPLE_ELEM(2, 0, colors)),	\
			GEN_STRUCT(type, size,					\
				BOOST_PP_TUPLE_ELEM(2, 1, colors))	\
		)											\
 
//--------------------------------------
 
#define GEN_UNION_REP_MACRO(z, n, param)			\
		GEN_STRUCT(									\
			BOOST_PP_TUPLE_ELEM(3, 0, param),		\
			BOOST_PP_TUPLE_ELEM(3, 1, param),		\
			BOOST_PP_ARRAY_ELEM(n,					\
				BOOST_PP_TUPLE_ELEM(3, 2, param)	\
			)										\
		);											\
 
#define GEN_UNION(type, size, arrays, colors)		\
		union {										\
			type	_a[size];						\
			BOOST_PP_REPEAT_FROM_TO(				\
				0,									\
				BOOST_PP_ARRAY_SIZE(arrays),		\
				GEN_UNION_REP_MACRO,				\
				(type, size, arrays)				\
			)										\
			GEN_COLOR_STRUCT(type, size, colors);	\
		}											\
 
GEN_UNION(float, 3, ELEMENT_ARRAYS, COLOR_ARRAYS);
GEN_UNION(float, 2, ELEMENT_ARRAYS, COLOR_ARRAYS);
 
//---------------------------------------------------------------------------
 
#define GEN_TPL_STRUCT(type, name, size, arrays, colors)	\
		struct	name<type, size> {							\
			GEN_UNION(type, size, arrays, colors);			\
		}													\
 
//---------------------------------------------------------------------------
 
template<typename typeT>
GEN_TPL_STRUCT(typeT, vec_struct, 2, ELEMENT_ARRAYS, COLOR_ARRAYS);
 
template<typename typeT>
GEN_TPL_STRUCT(typeT, vec_struct, 3, ELEMENT_ARRAYS, COLOR_ARRAYS);
 
template<typename typeT>
GEN_TPL_STRUCT(typeT, vec_struct, 4, ELEMENT_ARRAYS, COLOR_ARRAYS);
 
//---------------------------------------------------------------------------
 
#define GEN_TPL_CONCRETE_STRUCT(type, name, size, tpl)	\
		struct name##size : public tpl<type, size>		\
 
template<typename typeT>
GEN_TPL_CONCRETE_STRUCT(kazu::blast<typeT>::scalar, kazu::blast<typeT>::vec, 2, vec_struct)
{
};
 
template<typename typeT>
GEN_TPL_CONCRETE_STRUCT(kazu::blast<typeT>::scalar, kazu::blast<typeT>::vec, 3, vec_struct)
{
};
 
template<typename typeT>
GEN_TPL_CONCRETE_STRUCT(kazu::blast<typeT>::scalar, kazu::blast<typeT>::vec, 4, vec_struct)
{
};
 
//---------------------------------------------------------------------------
 
static void test_it()
{
	kazu::blast<float>::vec2 fv2;
	fv2.x = 0.0f;
	fv2.y = 1.0f;	
}
 
//---------------------------------------------------------------------------