Possible Duplicate:
Could anyone explain these undefined behaviors (i = i++ + ++i , i = i++, etc…)
#include<stdio.h>
#include<conio.h>
#define SQ(x) x*x
void main()
{
int a1 , a2;
int b1 , b2;
a1 = 2;
a2 = 2;
b1 = 0;
b2 = 0;
b1 = SQ(a1++);
b2 = SQ(++a2);
printf("Frist = %d",b1);
printf("Second = %d",b2);
}
I know what is the output of the code.
as #define work in other programe that way it is not working in above code Why.?
The result of an expression with more than one ++ operator on the same variable is officially an undefined behavior in C.
#define is an instruction to the preprocessor to literally replace each occurrence of the macro with its expansion. So the relevant lines in your code will pass to the compiler as:
b1 = a1++ * a1++;
b2 = ++a2 * ++a2;
As Seva states, these expressions are officially undefined; but even if we take what is arguably the most sensible reading you'll still get b1 = 2 * 3; and b2 = 3 * 4; (with both a1 and a2 set to 4 after the lines.
Both uses of SQ invoke undefined behaviour, as they are assigning to a1 and a2 more than once per sequence point. You should not pass expressions with side effects such as assignments or increments to macros.
because define just replaces the expression. so you get in result:
b1 = (a1++)*(a1++);
b2 = (++a2)*(++a2;
So, you get double increment twice. It results in undefined behaviour.
Congratulations! You have just discovered why it is a bad idea to use macros for this sort of thing. As a general rule, only make something a macro if it cannot be done using a function. In this case, SQ could easily be implemented as a function instead:
int sq (int x)
{
return x * x;
}
Wrap the operands in the macro between parenthesis:
#define SQ(X) (X)*(X)
Also, try not to operate with x++ and x in the same assignment. Could lead to undefined behavior.
Cheers!
The lines
b1 = SQ(a1++);
b2 = SQ(++a2);
expand to
b1 = a1++ * a1++;
b2 = ++a2 * ++a2;
which invoke undefined behavior (an object may have its value modified at most once between sequence points), meaning any result is considered "correct".
That's the problem with these sorts of macros; you really want the argument to be evaluated once, but because of the expansion it gets evaluated twice.
There's also the problem with calling it with an expression like
x = SQ(a + b);
This will expand to
x = a + b * a + b;
which is probably not what you wanted. To preserve operator precedence, the expansion should be wrapped in (), such as
#define SQ(x) (x) * (x)
Look at the code as it will be expanded by the preprocessor:
b1 = a1++ * a1++;
b2 = ++a2 * ++a2;
This is undefined behavior, because you are modifying a variable more than once without a sequence point between them.
I really don't know what your question is, but maybe you have problems with your expected output...
Be aware that #define is a "simple" text-replacement that is running before your code compiles.
This text-replacement has no respect for scope or syntactic correctnes.. it just replaces anything that matches with what you said it.
In your case it would not really make a square of the result of "a++", instead it would
generate this code: b1 = a++ * a++;
If you look here: Question about C programming you can see some explanations as why "a++ * a++" is officially undefined behaviour.
