Macro result malfunction in an operation

Question

I tried with this macro:

#define min(x,y) x<y? x:y

It's supposed to return the minimum and it does. The only problem is when trying to use the result of that macro in an operation, it doesn't work.

Example

x=min(3,4);

Here x will naturally have 3 as a value, but when trying this:

x= 23 + min(3,4);

the result will still always be 3 (the result of the macro), no matter what number I add to it (23 was arbitrary in there). May I know why this happens?

As always when facing a problem with macros, use a compiler switch to check what the preprocessor made of it. — Jongware, Jan 15 '16 at 23:29
see this post http://stackoverflow.com/questions/3437404/min-and-max-in-c — terence hill, Jan 15 '16 at 23:29

Danny_ds · Answer 1 · 2016-01-15T23:38:52.110

2

min should be defined as:

#define min(a,b)  (((a) < (b)) ? (a) : (b))

You also seem to be mixing MIN and min. C is case sensitive, so min() could be calling something else.

#define min(X,Y) X<Y? X:Y  // I changed MIN to lowercase here
x= 23 + min(3,4);

-> will expand to:

x = 23 + 3 < 4 ? 3 : 4;

which is the same as:

x = (23 + 3) < 4 ? 3 : 4;

That's why parentheses are needed:

x = 23 + ((3 < 4) ? 3 : 4);

To avoid further problems with for example: min(x | b + 4 / 2, y && 0x01 + 3);, parentheses are added around all the values:

(((a) < (b)) ? (a) : (b))

When using such macro's, care should be taken with the following:

int y = 1;
int z = 2;

x = min(y++, z++);

This evaluates to:

x = ((y++ < z++) ? y++ : z++); // some parentheses omitted

Which is not wat we want. y or z will be incremented twice.

edited Jan 15 '16 at 23:38

answered Jan 15 '16 at 23:20

Danny_ds

11,201
1
24
46

@Jdoe - I'm adding more info – Danny_ds Jan 15 '16 at 23:22
as a matter of fact I used I defined it as min not MIN and I tried it with a whole different name and still the same thing. – J doe Jan 15 '16 at 23:24
@Jdoe - So, never say too fast: _"min works just fine"_ :) – Danny_ds Jan 15 '16 at 23:34

score 2 · Answer 2 · answered Jan 15 '16 at 23:28

The problem is operator assocativity and precedence. When you expand the macro, it becomes:

x = 23 + 3 < 4 ? 3 : 4;

which is interpreted as:

x = (23 + 3) < 4 ? 3 : 4;

because arithmetic has higher precedence than comparison operators. You should wrap the expansion in parentheses to force it to be treated as a single expression.

#define min(x,y) (x<y? x:y)

You should also put parenthese around the uses of each parameter, in case they're expressions with operators that have lower precedence than <.

#define min(x,y) ( (x) < (y) ? (x) : (y) )

DEMO

But using a macro for a function like this is still a bad idea. All the repetitions of the parameters mean that you can't use it with expressions with side effects. E.g. min(i++, j++) will increment one of the variables twice. It would be better to use an inline function.

score 1 · Answer 3 · answered Jan 15 '16 at 23:27

1

This is a good example of why parenthesis in macros is important.

This:

x= 23 + min(3,4);

Expands to this:

x= 23 + 3<4? 3:4;

Which, with implicit parenthesis, is the same as:

x= ((23 + 3)<4)? 3:4;

This evaluates to 4.

If you define your macro like this:

#define min(x,y) ((x)<(y)?(x):(y))

Then you get this:

x= 23 + ((3)<(4)?(3):(4));

The ternary evaluates to 3, so x is assigned 26.

answered Jan 15 '16 at 23:27

dbush

205,898
23
218
273

Oh my! thanks so much!!! – J doe Jan 15 '16 at 23:31

score 0 · Answer 4 · answered Jan 15 '16 at 23:27

It's because + has the highest precedence, < is next and ? has the lowest precedence. So,

23 + min(3,4)

expands to

23 + 3 < 4 ? 3 : 4

So, the addition is done first, and then you'd have:

26 < 4 ? 3 : 4

Then the relational operator is done, and you'd have:

0 ? 3 : 4

So, you should actually be getting 4 as the result.

Macro result malfunction in an operation

4 Answers4