Carré d’un nombre en cours de définition avec #define

Je parcourais juste un certain code qui est fréquemment demandé dans les entretiens. Je suis venu avec certaines questions, si quelqu’un peut m’aider à ce sujet?

Je suis totalement confus à ce sujet maintenant,

#include  #include  #define square(x) x*x main() { int i, j; i = 4/square(4); j = 64/square(4); printf("\n %d", i); printf("\n %d", j); printf("\n %d", square(4)); getch(); } 

La sortie est:

  4 64 16 

Je me demande pourquoi square(4) renvoie-t-il 1 quand je l’ai divisé? Je veux dire, comment puis-je obtenir les valeurs 4 et 64 quand je les divise, mais quand on l’utilise directement, j’en ai 16 !!?

square est sous-parenthèses: il s’agrandit textuellement, donc

 #define square(x) x*x ... i=4/square(4); 

veux dire

 i=4/4*4; 

quels groupes comme (4/4) * 4 . Pour résoudre ce problème, ajoutez des parenthèses:

 #define square(x) ((x)*(x)) 

#Define est encore très incertain car il évalue x deux fois, donc square(somefun()) appelle la fonction deux fois et ne calcule donc pas nécessairement un carré mais bien le produit des deux appels successifs, bien sûr ;-).

Lorsque vous écrivez i=4/square(4) , le préprocesseur le développe en i = 4 / 4 * 4 .
Comme C regroupe les opérations de gauche à droite, le compilateur interprète cela comme i = (4 / 4) * 4 , ce qui équivaut à 1 * 4 .

Vous devez append des parenthèses, comme ceci:

 #define square(x) ((x)*(x)) 

De cette façon, i=4/square(4) devient i = 4 / ((4) * (4)) .
Vous avez besoin des parenthèses supplémentaires autour de x si vous écrivez un square(1 + 1) , qui se transformerait sinon en 1 + 1 * 1 + 1 , évalué comme 1 + (1 * 1) + 1 ou 3 .

 i=4/square(4); 

s’étend à

 i=4/4*4; 

qui équivaut à

 i=(4/4)*4; 

La priorité des opérateurs vous fait mal.

La macro est développée par le pré-processeur de telle sorte que

  i=4/4*4; j=64/4*4; 

ce qui équivaut à:

  i=(4/4)*4; j=(64/4)*4; 

C’est parce que le compilateur le remplace par:

 i=4/4*4; j=64/4*4; 

i = (4/4) * 4 = 1 * 4 = 4.

j = (64/4) * 4 = 16 * 4 = 64.

j = 4/square(4) == 4/4*4 == 1*4 == 4

Développez manuellement la macro dans le code, et ce sera clair. En d’autres termes, remplacez tout le carré (x) par x * x, en particulier, n’ajoutez aucune parenthèse.

définir est juste une macro de texte

 main() { int i,j; i=4/ 4 * 4; // 1 * 4 j=64/4 * 4; // 16 * 4 printf("\n %d",i); printf("\n %d",j); printf("\n %d",square(4)); getch(); } 

C’est une macro! Donc, il retourne exactement ce qu’il substitue.

 i = 4/4*4; Which is 4... j = 64/4*4; Which is 16... 

Essayez ceci pour votre macro:

 #define square(x) ((x)*(x)) 

En raison de la priorité des opérateurs dans l’expression après le préprocesseur – vous devrez écrire

 #define square(x) (x*x) 

Comme le disent les autres réponses, vous êtes brûlé par la priorité des opérateurs. Changez votre macro carrée en ceci:

 #define square(x) (x*x) 

et cela fonctionnera comme vous le souhaitez.