The need for parentheses in macros in C [duplicate]

Answer 1

Pre-processor macros perform text-replacement before the code is compiled so SQR(b+5) translates to (b+5*b+5) = (6b+5) = 6*3+5 = 23

Regular function calls would calculate the value of the parameter (b+3) before passing it to the function, but since a macro is pre-compiled replacement, the algebraic order of operations becomes very important.

Answer 2

Consider the macro replacement using this macro:

#define SQR(x) (x*x)

Using b+5 as the argument. Do the replacement yourself. In your code, SQR(b+5) will become: (b+5*b+5), or (3+5*3+5). Now remember your operator precedence rules: * before +. So this is evaluated as: (3+15+5), or 23.

The second version of the macro:

#define SQR(x) ((x) * (x))

Is correct, because you're using the parens to sheild your macro arguments from the effects of operator precedence.

This page explaining operator preference for C has a nice chart. Here's the relevant section of the C11 reference document.

The thing to remember here is that you should get in the habit of always shielding any arguments in your macros, using parens.

Answer 3

After preprocessing, SQR(b+5) will be expanded to (b+5*b+5). This is obviously not correct.

There are two common errors in the definition of SQR:

1. do not enclose arguments of macro in parentheses in the macro body, so if those arguments are expressions, operators with different precedences in those expressions may cause problem. Here is a version that fixed this problem

   #define SQR(x) ((x)*(x))
   

2. evaluate arguments of macro more than once, so if those arguments are expressions that have side effect, those side effect could be taken more than once. For example, consider the result of SQR(++x).

   By using GCC typeof extension, this problem can be fixed like this

   #define SQR(x) ({ typeof (x) _x = (x); _x * _x; })
   

Both of these problems could be fixed by replacing that macro with an inline function

   inline int SQR(x) { return x * x; }

This requires GCC inline extension or C99, See 6.40 An Inline Function is As Fast As a Macro.

Answer 4

Because (3+5*3+5 == 23).

Whereas ((3+5)*(3+5)) == 64.

The best way to do this is not to use a macro:

inline int SQR(int x) { return x*x; }

Or simply write x*x.

Answer 5

Just enclose each and every argument in the macro expansion into parentheses.

#define SQR(x) ((x)*(x))

This will work for whatever argument or value you pass.

Answer 6

A macro is just a straight text substitution. After preprocessing, your code looks like:

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

Multiplication has a higher operator precedence than addition, so it's done before the two additions when calculating the value for a. Adding parentheses to your macro definition fixes the problem by making it:

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

The parenthesized operations are evaluated before the multiplication, so the additions happen first now, and you get the a = 64 result that you expect.