Intereting Posts

gcc: impossible de créer .so à partir de fichiers objects Quel est le moyen le plus efficace de représenter de petites valeurs dans une structure? Comment boucler une chaîne créée par un pointeur Comment définir une taille de fenêtre fixe pour une application GTK + en C? retourne un tableau de chaîne d’une fonction ne fonctionnant pas comme prévu Quand utiliser des macros de type fonction en C Ghashtable stockant double Tokenizing une chaîne en C? Programmes C threadés dans minGW C et pointeur dans une fonction – les modifications ne sont pas enregistrées Erreur de segmentation lors de la lecture d’un fichier binary dans une structure comparer off_t et ssize_t avec d’autres types off_t sans -D_FILE_OFFSET_BITS = 64 sur un fichier> 2 Go Existe-t-il un équivalent CUDA de perror ()? En utilisant la flèche -> et le point. opérateurs réunis en C

Macros C et utilisation des arguments entre parenthèses

Exemple

#define Echo(a) a #define Echo(a) (a)

Je me rends compte qu’il n’y a probablement pas de différence significative ici, mais pourquoi voudriez-vous jamais inclure a entre parenthèses dans le corps de la macro? Comment cela change-t-il?

Supposons que vous ayez

 #define mul(x, y) x * y

Qu’est-ce qui se passe si je dis:

 mul(a + 5, 6); /* a + 5 * 6 */

Maintenant si je change légèrement la macro:

 #define mul(x, y) ((x) * (y)) mul(a + 5, 6); /* ((a + 5) * (6)) */

Rappelez-vous, les arguments ne sont pas évalués ou quoi que ce soit, seule la substitution textuelle est effectuée.

MODIFIER

Pour une explication sur la macro entière entre parenthèses, voir le lien posté par Nate CK .

Pour mémoire, j’ai atterri à partir d’ici. Comment corriger les erreurs mathématiques lors de l’utilisation de macros et je vais essayer d’élargir cette Réponse à l’autre.

Vous parlez de la différence à propos de:

 #define Echo( a ) a #define Echo( a ) ( a )

ce qui est bien tant que vous ne comprenez pas la macro elle-même (je ne suis pas un expert aussi :)).

Tout d’abord, vous savez déjà (probablement) qu’il existe une préséance d’opérateur. Il existe donc une différence énorme entre ces deux programmes:

1):

 #include  #define ADD( a , b ) a + b int main( void ) { auto const int a = 5; auto const int b = 10; auto const int c = ADD ( 2 + a , 2 + b ); printf( "%d", c ); return 0; }

Sortie:

et:

 #include  #define ADD( a , b ) ( a ) + ( b ) int main( void ) { auto const int a = 5; auto const int b = 10; auto const int c = ADD ( a , b ); printf( "%d", c ); return 0; }

Sortie:

15

Maintenant, remplaçons + avec * :

 #define ADD( a, b ) a * b

Le compilateur traite a * b comme par exemple a == 5 et b == 10 ce qui fait 5 * 10 .

Mais, quand vous dites: ADD ( 2 + a * 5 + b ) Comme ici:

 #include  #define ADD( a , b ) ( a ) * ( b ) int main( void ) { auto const int a = 5; auto const int b = 10; auto const int c = ADD ( 2 + a , 5 + b ); printf( "%d", c ); return 0; }

Vous obtenez 105 , car la priorité de l’opérateur est impliquée et traite

2 + b * 5 + a

comme

( 2 + 5 ) * ( 5 + 10 )

lequel est

( 7 ) * ( 15 ) == 105

Mais quand tu fais:

 #include  #define ADD( a, b ) a * b int main( void ) { auto const int a = 5; auto const int b = 10; auto const int c = ADD ( 2 + a , 5 + b ); printf( "%d", c ); return 0; }

vous en avez 37 cause de

  2 + 5 * 5 + 10

ce qui signifie:

 2 + ( 5 * 5 ) + 10

ce qui signifie:

 2 + 25 + 10

Réponse courte, il y a une grande différence entre:

 #define ADD( a , b ) a * b

 #define ADD( a , b ) ( a ) * ( a )