Inclure une condition dans un define

Version imprimable

26/03/2015, 12h15
webshaker

Inclure une condition dans un define
Salut est il possible de modifier un define en fonction de son paramètre.

Par exemple j'ai ce défine
Code:

1 2 3 4 5 6 7 8 #define testDef(VAR) return (VAR); ... int fct() { ... testDef(-5) // doit être remplacé par return(--5); }
comment puis-je remplacer
testDef(VAR) par return (VAR); si VAR est > 0

et par return (-VAR); sinon ?

C'est possible de faire ça ?
26/03/2015, 12h22
Kaamui

C'est possible mais il ne faut pas. L'utilisation des #define pour définir une fonction est à proscrire.

Ne cache surtout pas ton return dans une macro ton code sera ensuite incompréhensible, et non maintenable.
26/03/2015, 12h58
ternel
Un define ne devrait définir que des valeurs, ou si vraiment tu y tiens, des expressions.
return est une instruction, qu'il ne faut pas utiliser ainsi.

Pour éviter des tas de problème, il faudrait toujours qu'une macro utilisable dans le code soit une valeur.

Par contre, tu pourrais utiliser return M_TEST_VALEUR(-5).
Du coup, c'est une sorte de fonction, que tu devrais définir comme telle.
Code:

1 2 3 4 5 6 7 inline int testDef(int VAR) {return VAR < 0 ? -VAR : var;} ... int fct() { ... return testDef(-5); }
Par contre, si la macro ne sert qu'au préprocesseur, c'est un autre problème.
Les macros "fonctions" ne sont vraiment intéressantes que lorsque tu utilises les opérateurs magiques (# et ##).

Même pour définir des valeurs les macros n'apportent aucun avantage.

Elles ne restent que par souci de compatibilité avec du vieux C++, mais je ne crois pas qu'elles doivent être utilisées pour autre chose que des directives préprocesseur prédéfinies, ou pour introduire des portions de code en mode Debug uniquement, etc...

Pour définir une fonction, définis une fonction, comme l'exemple de @leternel. Pour définir une constante :
Code:

1 2 3 #define toto 5 //bad practice const int toto = 5;
Autre chose :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #define testDef(VAR) VAR > 0 ? return VAR : return -VAR int fct() { ... testDef(-5); } //En pre-processing, le define est trouvé dans fct et le code remplacé avant compilation et exécution... int fct() { -5 > 0 ? return -5 : return --5; }
Tu conçois que ton code ne vas pas te renvoyer 5 ou -5 (-- étant un opérateur de pré-incrémentation) ? (Si oui, tu conçois que c'est complètement tordu :D ?)

Merci, mais en fait j'avais simplement voulu simplifier mon exemple.

Mon define me permet de surcharger les operateurs.
voila le code exact

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
#define OperatorCastInt(OPE1, OPE2) \
	ebovar &ebovar::operator OPE2 (const ebovar &right_op) \
	{ \
		int ope = ((var_type << 2) + right_op.var_type) & 15; \
		switch(ope) \
		{ \
		case EBO_INT_INT:			i OPE2 right_op.i; break; \
		case EBO_INT_FLOAT:		i OPE2 (int)right_op.f; break; \
		case EBO_INT_STRING:		i OPE2 right_op.getInt(); break; \
		case EBO_FLOAT_INT:		i = (int)f OPE1 right_op.i; break; \
		case EBO_FLOAT_FLOAT:	i = (int)f OPE1 (int)right_op.f; break; \
		case EBO_FLOAT_STRING:	i = (int)f OPE1 right_op.getInt(); break; \
		case EBO_STRING_INT:		i = getInt() OPE1 right_op.i; break; \
		case EBO_STRING_FLOAT:	i = getInt() OPE1 (int)f; break; \
		case EBO_STRING_STRING:	i = getInt() OPE1 right_op.getInt(); break; \
		default: \
			printf("Error : can't apply operator OPE2 to this vartype (%s)\n", right_op.getType().c_str()); \
			break; \
		} \
		return *this; \
	} \
 \
	ebovar &ebovar::operator OPE2 (int ivalue) \
	{ \
		switch(var_type) \
		{ \
		case EBO_INT:				i OPE2 ivalue; break; \
		case EBO_FLOAT:			i = (int)f OPE1 ivalue; break; \
		case EBO_STRING:			i = getInt() OPE1 ivalue; break; \
		default: \
			printf("Error : can't apply operator OPE2 to this vartype (%s)\n", getType().c_str()); \
			break; \
		} \
		return *this; \
	} \
 \
	ebovar operator OPE1(const ebovar &left_op, const ebovar &right_op) \
	{ \
		int ope = ((left_op.var_type << 2) + right_op.var_type) & 15; \
		switch(ope) \
		{ \
		case EBO_INT_INT:			return (ebovar)(left_op.i OPE1 right_op.i); break; \
		case EBO_INT_FLOAT:		return (ebovar)(left_op.i OPE1 (int)right_op.f); break; \
		case EBO_INT_STRING:		return (ebovar)(left_op.i OPE1 right_op.getInt()); break; \
		case EBO_FLOAT_INT:		return (ebovar)((int)left_op.f OPE1 right_op.i); break; \
		case EBO_FLOAT_FLOAT:	return (ebovar)((int)left_op.f OPE1 (int)right_op.f); break; \
		case EBO_FLOAT_STRING:	return (ebovar)((int)left_op.f OPE1 right_op.getInt()); break; \
		case EBO_STRING_INT:		return (ebovar)(left_op.getInt() OPE1 right_op.i); break; \
		case EBO_STRING_FLOAT:	return (ebovar)(left_op.getInt() OPE1 (int)right_op.f); break; \
		case EBO_STRING_STRING:	return (ebovar)(left_op.getInt() OPE1 right_op.getInt()); break; \
		default: \
			printf("Error : can't apply operator OPE1 to this vartype (%s OPE1 %s)\n", left_op.getType().c_str(), right_op.getType().c_str()); \
			break; \
		} \
	} \
 \
	ebovar operator OPE1(const ebovar &left_op, int ivalue) \
	{ \
		switch(left_op.var_type) \
		{ \
		case EBO_INT:       return (ebovar)(left_op.i OPE1 ivalue); break; \
		case EBO_FLOAT:     return (ebovar)((int)left_op.f OPE1 ivalue);	break; \
		case EBO_STRING:    return (ebovar)(left_op.getInt() OPE1 ivalue); break; \
		default: \
			printf("Error : can't apply operator OPE1 to this vartype (%s)\n", left_op.getType().c_str()); \
			break; \
		} \
	} \
 \
	ebovar operator OPE1(int ivalue, const ebovar &right_op) \
	{ \
		switch(right_op.var_type) \
		{ \
		case EBO_INT:			return (ebovar)(ivalue OPE1 right_op.i); break; \
		case EBO_FLOAT:		return (ebovar)(ivalue OPE1 (int)right_op.f); break; \
		case EBO_STRING:		return (ebovar)(ivalue OPE1 right_op.getInt()); break; \
		default: \
			printf("Error : can't apply operator OPE1 to this vartype (%s)\n", right_op.getType().c_str()); \
			break; \
		} \
	}

Ca fonctionne sans problème pour la plupart des opérateurs.
Sauf que pour un seul opérateur, j'ai besoin d'opérer une petite modification.
Alors évidement je peux très bien réaliser cet opérateur dans avoir recours au define, mais cela me semblait plus simple...

Donc ma question est toujours d'actualité ;)
Comment changer une ligne de tout ce define au cas ou je l'appelle avec OP1 valant le caractère +

Merci.

26/03/2015, 17h24
Kaamui

La surcharge des opérateurs ne devrait pas non plus être faite ainsi... ce n'est ni plus simple, ni une bonne chose à faire : essaie de refaire tout ton code sans utiliser les macros. Pour la réponse que tu attends je t'ai déjà donné un exemple mais tu ne dois pas les utiliser ainsi.

Il ne s'agit que d'un alias qui va remplacé chaque appel au define par la portion de code en question.
27/03/2015, 09h15
webshaker
Citation:
Envoyé par Kaamui

Code:

1 2 #define testDef(VAR) VAR > 0 ? return VAR : return -VAR

Tu conçois que ton code ne vas pas te renvoyer 5 ou -5 (-- étant un opérateur de pré-incrémentation) ? (Si oui, tu conçois que c'est complètement tordu :D ?)
Merci je vais tester ça pur voir ce que ça donne.

Citation:
Envoyé par Kaamui
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #define testDef(VAR) VAR > 0 ? return VAR : return -VAR int fct() { ... testDef(-5); } //En pre-processing, le define est trouvé dans fct et le code remplacé avant compilation et exécution... int fct() { -5 > 0 ? return -5 : return --5; }
Ce code est faux, un return ne peut pas se trouver dans un opérateur ternaire.
http://kukuruku.co/hub/cpp/secrets-o...rnary-operator point 5

sinon les macros c'est comme le reste, très pratique, parfois indispensable, faut pas en abuser, mais pas non plus crier au bucher à leur moindre utilisation :roll:

28/03/2015, 23h16
Kaamui
Honnêtement j'étais au travail (et sur plein d'autres langages que le C++), j'ai pas vraiment testé l'essentiel du propos étant surtout de preciser les dangers d'utilisation de ce genre de code. Ne pas crier au boucher certes, mais il faut utiliser les choses a bon escient et les macros sont tres rarement le moyen le plus avantageux dans le temps. En cela je suis donc en total désaccord et je penses également qu'il ne faut pas banaliser leur utiliation aupres des personnes qui viennent chercher des conseils ici, car vous n'en maîtrisez pas les effets de bord
Code:

1 2 return VAR > 0 ? VAR : -VAR
03/04/2015, 15h12
bacelar

Heu, sinon, pourquoi ne pas utiliser la fonction abs ???

http://www.cplusplus.com/reference/cstdlib/abs/