Générer des operateurs avec Boost.Preprocessor (ou Boost.operators)

Version imprimable

J'essaye de générer des operateurs pour ma lib d'algèbre linéaire avec Boost.Preprocessor et ca marche pas.

En detail, 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
 
#define GEN_ALGEBRAIC_OPS_REP_MACRO(z, n, param)			\
		BOOST_PP_TUPLE_ELEM(2, 0, param)					\
		BOOST_PP_CAT(OPERATOR,								\
			BOOST_PP_ARRAY_ELEM(n,							\
				BOOST_PP_TUPLE_ELEM(2, 1, param)			\
			)												\
		)													\
		(const BOOST_PP_TUPLE_ELEM(2, 0, param)& rlv) const \
		{													\
			BOOST_PP_TUPLE_ELEM(2, 0, param)	rv;			\
			return rv;										\
		}													\
 
#define	GEN_ALGEBRAIC_OPS(type, size, operators)\
		BOOST_PP_REPEAT_FROM_TO(				\
			0,									\
			BOOST_PP_ARRAY_SIZE(operators),		\
			GEN_ALGEBRAIC_OPS_REP_MACRO,		\
			(type, operators)					\
		)										\

En générant mes operateurs pour un vec2 (par exemple) de la facon suivante

Code:

1
2
 
GEN_ALGEBRAIC_OPS(vec2, 2, ALGEBRAIC_OPS)

avec ALGEBRAIC_OPS défini comme

Code:

#define ALGEBRAIC_OPS (4, (Add, Sub, Mul, Div))

cela me donne

Code:

1
2
3
4
vec2 operatorAdd (const vec2& rlv) const { vec2 rv; return rv; } 
vec2 operatorSub (const vec2& rlv) const { vec2 rv; return rv; } 
vec2 operatorMul (const vec2& rlv) const { vec2 rv; return rv; } 
vec2 operatorDiv (const vec2& rlv) const { vec2 rv; return rv; }

comme attendu, mais avec ALGEBRAIC_OPS définis comme cela

Code:

#define ALGEBRAIC_OPS (4, (+, -, *, /))

j'obtiens l'erreur suivante:

Code:

1
2
3
4
error: pasting "operator" and "+" does not give a valid preprocessor token
error: pasting "operator" and "-" does not give a valid preprocessor token
error: pasting "operator" and "*" does not give a valid preprocessor token
error: pasting "operator" and "/" does not give a valid preprocessor token

des idées, voire des solutions?

Ok, c'était stupide comme solution mais efficace: "operator+" équivaut à "operator +", donc il suffit de ne pas concatener.

le code final (rendu plus facile au passage):

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	GEN_ALGEBRAIC_OP(type, size, op)					\
		type												\
		OPERATOR op											\
		(const type& rhs) const		{						\
			type rv;										\
			for(int i = 0; i < size; i++)	{				\
				rv._a[i] = this->_a[i] op rhs._a[i];		\
			}												\
			return rv;										\
		}													\
 
#define GEN_ALGEBRAIC_OPS_REP_MACRO(z, n, param)			\
		GEN_ALGEBRAIC_OP(									\
			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_ALGEBRAIC_OPS(type, size, operators)\
		BOOST_PP_REPEAT_FROM_TO(				\
			0,									\
			BOOST_PP_ARRAY_SIZE(operators),		\
			GEN_ALGEBRAIC_OPS_REP_MACRO,		\
			(type, size, operators)				\
		)										\

Au passage, quelqu'un s'est déjà servi du template operator et saurait me l'expliquer ?
http://www.boost.org/doc/libs/1_36_0.../operators.htm

25/08/2008, 15h22
Kurisu

Je marque ce point comme résolu, mais je vais en ouvrir un autre sous peu pour la prochaine question sur Boost.pp :P