El cuadrado de un número se define usando #define

Estaba revisando cierto código que se pregunta con frecuencia en las entrevistas. Se me ocurrieron ciertas preguntas, si alguien puede ayudarme con respecto a esto.

Estoy totalmente confundido sobre esto ahora,

#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(); } 

El resultado es:

  4 64 16 

Me pregunto, ¿por qué square(4) devolvió 1 cuando lo dividí? Quiero decir, ¿cómo puedo obtener el valor 4 y 64 cuando lo divido, pero cuando lo uso directamente obtengo 16 ?

square está entre paréntesis: se expande textualmente, por lo que

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

medio

 i=4/4*4; 

que se agrupa como (4/4) * 4 . Para corregir, agrega paréntesis:

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

Todavía es muy dudoso #define ya que evalúa x dos veces, por lo que square(somefun()) llama a la función dos veces y por lo tanto no calcula necesariamente un cuadrado, sino el producto de las dos llamadas sucesivas, por supuesto ;-).

Cuando escribe i=4/square(4) , el preprocesador lo expande a i = 4 / 4 * 4 .
Como C agrupa las operaciones de izquierda a derecha, el comstackdor interpreta eso como i = (4 / 4) * 4 , que es equivalente a 1 * 4 .

Necesita agregar paréntesis, como este:

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

De esta manera, i=4/square(4) convierte en i = 4 / ((4) * (4)) .
Necesita el paréntesis adicional alrededor de x en caso de que escriba square(1 + 1) , que de lo contrario se convertiría en 1 + 1 * 1 + 1 , que se evalúa como 1 + (1 * 1) + 1 o 3 .

 i=4/square(4); 

se expande a

 i=4/4*4; 

que equivalente a

 i=(4/4)*4; 

La precedencia del operador te está lastimando.

La macro se expande por el preprocesador de modo que

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

que es equivalente a:

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

Eso es porque el comstackdor lo reemplaza con:

 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

Expanda manualmente la macro en el código, y será claro. Es decir, reemplace todo el cuadrado (x) con exactamente x * x, en particular, no agregue ningún paréntesis.

definir es solo una macro de texto

 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(); } 

¡Es una macro! Por lo tanto, devuelve exactamente lo que sustituye.

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

Prueba esto para tu macro:

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

Debido a la precedencia del operador en la expresión después del preprocesador, necesitará escribir

 #define square(x) (x*x) 

Como dicen las otras respuestas, la prioridad del operador te quema. Cambie su macro cuadrada a esto:

 #define square(x) (x*x) 

y funcionará de la manera que esperas