Discussion :

[Carlaaaa1111]

Bonjour,

Je veux créer une macro qui transforme le contenu de son paramètre en sa valeur absolue.

Une solution qui marche est la suivante

Code :

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

#define ABS(x) (((x) < 0) ? -(x) : (x))

Mais cette solution (qui pour moi veux dire la même chose ne fonctionne pas .

Code :

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

1
2
3
4
#define ABS(Value) if (Value>=0)\
                        Value=Value;\
                    else if (Value<0)\
                        Value*=-1;

J'aimerais comprendre pourquoi.

Merci

[WhiteCrow]

Bonjour,
donner un exemple qui montre «ce qui ne fonctionne pas» est toujours plus parlant. Mais je peux me douter
La première macro est une expression qui a une valeur; la seconde est du code qui n'a pas de valeur. De plus ces macros ne sont pas très cools si tu donnes comme paramètre quelque chose comme : i++ …

Sinon, quand tu fais une macro comme celle-ci, il est préférable de l'encadrer par une fausse boucle while :

Code :

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

1
2
3
4
5
6
#define ABS(Value) do { \
                    if (Value>=0)\
                        Value=Value;\
                    else if (Value<0)\
                        Value*=-1;
                } while(0)

Mais ce qui est encore mieux → les fonctions static inline parce qu'en plus d'être une vraie fonction évite tous les problèmes inhérents aux macros →

Code :

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

1
2
3
4
5
 
static inline int abs(int a)
{
    return a<0?-a:a;
}

Désavantage : il te faut une fonction par type (en gros).

[foetus]

qui pour moi veux dire la même chose ne fonctionne pas

Certes mais cela ne veut pas dire que tu peux utiliser la nouvelle macro de la même manière.

1 test ternaire permet d'être inséré dans 1 ligne de code (1 return, 1 paramètre d'1 fonction par exemple) au contraire d'1 test classique qui lui est X lignes de code.

Et soit dit en passant , si 1 nombre n'est pas positif ni nul, il est forcément négatif donc else if (Value<0) est inutile.

[Carlaaaa1111]

Bonjour,
donner un exemple qui montre «ce qui ne fonctionne pas» est toujours plus parlant. Mais je peux me douter
La première macro est une expression qui a une valeur; la seconde est du code qui n'a pas de valeur. De plus ces macros ne sont pas très cools si tu donnes comme paramètre quelque chose comme : i++ …

Par exemple si je fais :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define ABS(Value) if (Value>=0)\
                        Value=Value;\
                    else if (Value<0)\
                        Value*=-1;
 
int main (int argc, char **argv)
{
               int Value;
 
               ABS(-5)
 
               printf("%d", Value);
 
}

Mon compilateur affiche :

 In function ‘main’:
ft_abs.h:2:30: error: lvalue required as left operand of assignment
    2 |                         Value=Value;\
      |                              ^
exo02.c:7:2: note: in expansion of macro ‘ABS’
    7 |  ABS(-5)
      |  ^~~
ft_abs.h:4:30: error: lvalue required as left operand of assignment
    4 |                         Value*=-1;
      |                              ^~
exo02.c:7:2: note: in expansion of macro ‘ABS’
    7 |  ABS(-5)
      |  ^~~

Pourtant ABS(-5) devrait être remplacé par la macro non ?

[foetus]

C'est normal ton paramètre de ta macro a le même nom qu'1 variable. @Sve@r a raison , le problème est que tu fais 1 auto-affectation qui 1) ne sert à rien si c'est 1 variable 2) plante avec 1 valeur fixe (ton problème justement)
Et effectivement je n'ai pas vu le problème

Et donc Value=Value; tu crois que cela faire quoi ? Simple, si tu passes en paramètre -5, alors tu vas avoir -5=-5 et -5*=-1.
Ton compilateur te dit gentiment qu'il ne pas faire d'affectation dans 1 valeur fixe : ce qui est logique

[Carlaaaa1111]

Ah je vois et donc en écrivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define ABS(Value) if (Value>=0)\
                       result=Value;\
                    else if (Value<0)\
                        result=Value*-1;
 
int main (int argc, char **argv)
{
               int result;
 
               ABS(-5)
 
               printf("%d", result);
 
}

Ca fonctionne! Par contre dans ces cas la je ne respecte pas l'énoncé qui dit "Ecrire une macro qui remplace son paramêtre pas sa valeur absolue" car Value n'est pas modifié

[Bousk]

Une macro n'est pas un truc magique. Ça remplace la macro par le code de la macro.
-5 n'est pas une variable, donc ta syntaxe est incorrecte.

Value n'est pas modifié

Value n'existe pas, dans la macro ce sera -5. Effectivement tu vas difficilement modifier la valeur d'un truc qui n'est pas une variable.

Code :

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

1
2
int result = -5;
ABS(result);

Et voilà.

[Sve@r]

Bonjour

Ca fonctionne!

Oui ça fonctionne mais c'est une des pires solutions qui soient car la macro n'a aucune indépendance vis à vis du reste du programme. Elle ne peut être utilisée qu'en partenariat avec une variable "result" (donc en fait à un seul endroit ce qui limite un peu son utilité) et si cette variable change ou disparait suite à évolution, tout le programme s'écroule.

Ton tout premier exemple (la solution qui fonctionne) reste encore ce qu'il y a de mieux

Code c :

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

1
2
3
4
5
6
#define ABS(x) ((x) < 0 ?-(x) :(x))
 
int main (int argc, char **argv) {
	int Value=ABS(-5);
	printf("%d", Value);
}

Mais cette solution (qui pour moi veux dire la même chose) ne fonctionne pas .

Code c :

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

1
2
3
4
#define ABS(Value) if (Value>=0)\
                        Value=Value;\
                    else if (Value<0)\
                        Value*=-1;

Elle ne veut pas dire la même chose. La première solution exprime une opération mathématique basée sur un opérateur du C. Exactement comme tu aurais pu exprimer un carré de cette façon #define CARRE(x) ((x) * (x)). Et elle pourra être utilisée dans toute circonstance où une expression algébrique (constante, calcul) est acceptée (affectation, paramètre de fonction, if(), while(), for()).
Cette second solution est déjà un bout de code avec une condition et une affectation. Ok au résultat c'est la même chose mais du point de vue C, ce n'est plus du tout pareil car le cheminement pour arriver au résultat n'est plus le même.
Accessoirement je n'arrive pas vraiment à percevoir l'utilité profonde de ce Value=Value...

Code c :

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

1
2
3
4
5
6
7
8
#define ABS(Value) if (Value<0) Value=-Value
 
int main (int argc, char **argv) {
	int Value=-5;
 
	ABS(Value);
	printf("%d", Value);
}

De plus, tu remarqueras que je n'ai pas mis de point-virgule à la fin de la macro. Ceci afin de pouvoir l'utiliser dans une expression où le point-virgule est interdit (paramètre d'une fonction, if(), while(), for()). Mais évidemment comme dans ce type d'expression l'affectation est elle-aussi interdite...

Par contre dans ces cas la je ne respecte pas l'énoncé qui dit "Ecrire une macro qui remplace son paramêtre pas sa valeur absolue" car Value n'est pas modifié

Effectivement l'énoncé est incorrectement formulé. Une macro n'a pas pour vocation de remplacer son paramètre par autre chose, mais d'utiliser le paramètre dans une expression.
Ou alors l'énoncé est bien formulé et alors jamais il n'aurait dû te venir à l'idée de lui passer une valeur directe et donc non modifiable

C'est normal ton paramètre de ta macro a le même nom qu'1 variable.

Cela n'a pas d'importance, les variables locales sont indépendantes de ce qui est en global (exactement comme tu pourrais créer une int Value en global sans perturber le compilateur). Tu peux reprendre mon premier exemple de ce post et remplacer "x" par "Value" ça fonctionnera. C'est parce que le pré-processeur fait une première passe et remplace toutes les macros par leur équivalent. Quand l'analyseur syntaxique arrive, il reçoit un code sans aucune macro et donc ne voit pas de paramètre identique à la variable.

[Carlaaaa1111]

Merci à tous pour vos réponses je commence a saisir le principe.

Y'aurait-il d'autres solutions possible histoire que je comprenne bien comment ça marche?

Bonjour

Oui ça fonctionne mais c'est une des pires solutions qui soient car la macro n'a aucune indépendance vis à vis du reste du programme. Elle ne peut être utilisée qu'en partenariat avec une variable "result" (donc en fait à un seul endroit ce qui limite un peu son utilité) et si cette variable change ou disparait suite à évolution, tout le programme s'écroule.

ton tout premier exemple (la solution qui fonctionne) reste encore ce qu'il y a de mieux

Code :

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

#define ABS(x) ((x) < 0 ?-(x) :(x))

D'accord je vois mais je n'ai pas bien compris dans cette exemple ca remplace le code par ((x) < 0 ?-(x) : (x)) ou ca remplace le code par x si x>0 et par -x si x<0 ?

[Sve@r]

D'accord je vois mais je n'ai pas bien compris dans cette exemple ca remplace le code par ((x) < 0 ?-(x) : (x)) ou ca remplace le code par x si x>0 et par -x si x<0 ?

Une macro remplace intégralement "x" par ce que tu lui mets. Exemple ABS(1-8) donnera ((1-8) < 0 ?-(1-8) :(1-8)). C'est d'ailleurs pour ça qu'on place "x" entre parenthèse à chaque fois qu'on l'utilise. Et les parenthèses globales permettent d'intégrer la macro dans un calcul plus large sans avoir de souci de priorité.
Ne reste que le cas du ABS(i++) qui donnera ((i++) < 0 ?-(i++) :(i++)) produisant alors un lourd effet de bord impossible à résoudre. C'est pour ça qu'on ne met jamais d'opération d'auto-modification quand on appelle une macro (d'où l'écriture en majuscules pour permettre de la repérer). Sauf que certaines fonctions sont en réalité des macros cachées pour accélérer l'appel (ex isupper()) et que de façon plus générale, il vaut mieux ne jamais mettre d'opération d'auto-modification en paramètre d'une fonction (parce que franchement, entre fct(i++) et fct(i); i++ la première écriture n'est là que pour se la pêter et ne change absolument rien à la vitesse du code tout en pouvant tout faire crasher si fct() est en réalité une macro qui utilise plusieurs fois son paramètre).

Et éventuellement ne plus utiliser de macro paramétrée et utiliser le inline montré par WhiteCrow qui nous vient du C++.

[Carlaaaa1111]

D'accord je comprend mieux merci. Je vais continuer a m'entrainer.