Why is the output different in these two scenarios

Question

Please give me full description.... The first snippet of code has the 'function call' (macro invocation) before the increment operator, and second one has the function call after the increment operator.

#include <stdio.h>
#define square(x) x*x
int main()
{
  int a,b=3;
  a=square (b)++;
  printf("%d%d",a,b);
  return 0;
}

output:

why is 124 returned here

#include <stdio.h>
#define square(x) x*x
int main()
{
  int a,b=3;
  a=square (b++);
  printf("%d%d",a,b);
  return 0;
}

output:

and 125 here?

Aside `printf` there is no function called by the code you show. Macros are not functions. — alk, May 12 '19 at 17:49
Why not have a look at the pre-processed code, the code with the macros being replaced? — alk, May 12 '19 at 17:51
No, review what post increment does (you can try c=b++; and print c) — , May 12 '19 at 17:55
The 2nd snippet invokes undefined behaviour as `square (b++)` expands to `b++ * b++`. So the question cannot be answered on language level as Undefined Behaviour by its nature is undefined. — alk, May 12 '19 at 18:15
Please see [this answer](https://stackoverflow.com/a/4176333/694576) which although tagged C++ applies to C as well. — alk, May 12 '19 at 18:15
You should probably use at least once space between the two `%d` conversion specifications, and should preferably output a newline at the end of the printing. — Jonathan Leffler, May 12 '19 at 21:41

Tom Karzes · Answer 1 · 2019-05-12T20:11:34.237

The thing to keep in mind is that macros provide simple substitution of preprocessor tokens. In particular, they may evaluate their arguments more than once, and if not guarded by parentheses, they may produce unintended reassociation.

In the first example, we have

a=square (b)++;

This expands to:

a=b*b++;

This is actually undefined behavior, since the b and b++ are unsequenced, and b++ modifies b. In your case, you are seeing 12 and 4 for a and b, so it would seem that the first value of b is picking up the incremented value, so you're getting 4*3, but you can't count on this behavior. The final value of b is 4 since it is incremented once.

In the second example, we have:

a=square (b++);

This expands to:

a=b++*b++;

This is again undefined behavior. In your case, it appears that you're getting 4*3 (or 3*4), but again, you can't count on this behavior. The final value of b is 5 since it is incremented twice, but this too is undefined behavior.

alx - recommends codidact · Answer 2 · 2019-05-12T22:42:21.973

In addition to Tom's answer, which explains what is happening, here is an example of how you could define a macro for squaring a number safely:

#define SQR(x) (                    \
{                                   \
        __auto_type x_  = (x);      \
                                    \
        x_ * x_;                    \
}                                   \
)

It only has an appearance of x, and therefore it doesn't evaluate it twice. The copy x_ is used instead. Note that variables created in a macro may conflict with other variables created in the function that calls the macro. To avoid name collisions you use special names that shouldn't be used in normal code such as a trailing _.

With this macro, this:

a = SQR(b++);

will be equivalent to this:

a = SQR(b);
b++;

Warning: This works on some compilers as an extension (GCC for example), but it is not standard C.

Another option, if you want standard C, is to use an inline function. It is ok if you want it to work on just one type (there is _Generic in C11, but I never used it, so no idea).

Why is the output different in these two scenarios

2 Answers2