宏和后增量

Question

Here's some more weird macro behavior I was hoping somebody could shed light on:

#define MAX(a,b) (a>b?a:b)

void main(void)
{
  int a = 3, b=4;

  printf("%d %d %d\n",a,b,MAX(a++,b++));
}

The output is 4 6 5. The value of b is incremented twice but not before MAX displays its value. Can anybody please tell me why this is happening and how does one predict such behavior? (Another instance of why macros should be avoided!)

Answer 1

Macros do text substitution. Your code is equivalent to:

printf("%d %d %d\n",a,b, a++ > b++ ? a++ : b++);

This has undefined behavior, because b is potentially incremented (at the end of the third argument) and then used (in the second argument) without an intervening sequence point.

But as with any UB, if you stare at it for a while you might be able to come up with an explanation of what your implementation has actually done to yield the result you see. Order of evaluation of arguments is unspecified, but it looks to me as though the arguments have been evaluated in right-to-left order. So first, a and b are incremented once. a is not greater than b , so b is incremented again and the result of the conditional expression is 5 (that is to say, b after the first increment and before the second).

This behavior is not reliable - another implementation or the same implementation on another day might give different results due to evaluating the arguments in a different order, or theoretically might even crash because of the sequence point issue.

Answer 2

In macro, parameters are just replaced by the arguments; so arguments can be evaluated multiple times if they are present multiple times in the macro.

Your example:

MAX(a++,b++)

Expands to this:

a++>b++?a++:b++

I think you don't need more explanations :)

You can prevent this by assigning each parameter to a temporary variable:

#define MAX(a,b) ({   \
    typeof(a) _a = a; \
    typeof(b) _b = b; \
    a > b ? a : b;    \
})

(This one uses several GCC extensions, though)

Or use inline functions:

int MAX(int a, int b) {
    return a > b ? a : b;
}

This will be as good as a macro at runtime.

Or don't do the increments in the macro arguments:

a++;
b++;
MAX(a, b)

Answer 3

When the preprocessor reads the line it replace the MAX(a++,b++) in the printf to the (a++>b++?a++;b++)

So your function becomes

    printf(a,b,(a++>b++?a++;b++));

Here order of evaluation is "compiler dependent".

To understand when these conditions can occur u have to understand about Sequence point.

At each sequence point, the side effects of all previous expressions will be completed(all the variable calculation will be completed). This is why you cannot rely on expressions such as:

    a[i] = i++;

because there is no sequence point specified for the assignment, increment or index operators, you don't know when the effect of the increment on i occurs. “Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression. Furthermore, the prior value shall be read only to determine the value to be stored.”. If a program breaks these rules, the results on any particular implementation are entirely unpredictable(undefined).

--The sequence points laid down in the Standard are the following:

1) The point of calling a function, after evaluating its arguments.

2) The end of the first operand of the && operator.

3)The end of the first operand of the || operator.

4)The end of the first operand of the ?: conditional operator.

5)The end of the each operand of the comma operator.

6)Completing the evaluation of a full expression. They are the following:

Evaluating the initializer of an auto object.

The expression in an 'ordinary' statement—an expression followed by semicolon.

The controlling expressions in do, while, if, switch or for statements.

The other two expressions in a for statement.

The expression in a return statement.

Answer 4

Macros are evaluated by the preprocessor which stupidly replaces all according to the macro definitions. In your case, MAX(a++, b++) becomes (a++>b++) ? a++ : b++ (a++>b++) ? a++ : b++ .

Answer 5

If i'm correct, this is happening:

with MAX replaced with (a>b...) you have printf("%d %d %d\\n",a,b,(a++ > b++ ? a++ : b++ ) );

First, a++ > b++ is checked and both values increased (a = 4, b = 5) afterwards. Then the second b++ gets active, but because it's postincrement, it's increased after the second value b = 5 is printed.

Sorry for my bad english, but i hope you understand it?! :D

Greeings from Germany ;-)

Ralf

Answer 6

So your expansion gives (adjusted for clarity):

(a++ > b++) ? a++ : b++

... so (a++ > b++) is evaluated first, giving one increment each and selecting a branch based on the not-yet-incremented values of a and b . The 'else' expression is chosen, b++ , which does the second increment on b , which was already incremented in the test expression. Since it's a post-increment, the value of b before the second increment is given to printf() .

Answer 7

There are two reasons for the result that you're getting here:

1. A macro is nothing but code that is expanded and pasted when you compile. So your macro

    MAX(a,b) (a>b?a:b) 

   becomes this

    a++>b++?a++:b++ 

   and your resulting functions is this:

    printf("%d %d %d\\n",a,b, a++>b++?a++:b++); 

   Now it should be clear why b is incremented twice: first in comparison, second when returning it. This is not undefined behaviour, it is well defined, just analyse the code and you'll see what exactly to expect. (it is predictable in a way)

2. The second problem here is that in C parameters are passed from last to first to the stack, hence all the incrementation will be done before you print the original values of a and b, even if they're listed first. Try this line of code and you'll understand what I mean:
   

    int main(void) { int a = 3, b=4; printf("%d %d %d\\n",a,b, b++); return 0; } 

The output will be 3 5 4. I hope this explains the behaviour and will help you to predict the result.
BUT , the last point depends in your compiler

Answer 8

I think the questioner was expecting the output to start:

3 4 ...

instead of:

4 6 ...

and this is because the parameters are being evaluated from right to left as they are being pushed onto the stack, that is, the last parameter is being evaluated first and pushed, then the second to last, then the second parameter and finally the first parameter.

I think (and someone post a comment if it's wrong) that this is defined in the C standard (and C++).

Update

The order of evaluation is defined, but it's defined as undefined (thanks Steve). Your compiler just happens to do it this way. I think I got confused between evaluation order and the order the parameters are passed.