#define used with operators

Question

I know that #define has the following syntax: #define SYMBOL string If I write, for example

#define ALPHA 2-1
#define BETA ALPHA*2

then ALPHA = 1 but BETA = 0.(why ?)

But if i write something like this

#define ALPHA (2-1)
#define BETA ALPHA*2

then ALPHA = 1 and BETA = 2.

Can someone explain me what's the difference between those two ?

`#define` just copy-pastes everything, so that `#define BETA ALPHA*2` becomes `#define BETA 2-1*2`, where operator precedence kicks in (i.e. multiplication done first). — Algirdas Preidžius, Jul 27 '17 at 13:27
your assumptions are incorrect. after `#define ALPHA (2-1)` ALPHA is just `(2-1)` . You can [check here](https://godbolt.org/g/mCNumn) to see the output after preprocessing — 463035818_is_not_an_ai, Jul 27 '17 at 13:28
maybe you used something like `std::cout << ALPHA;` to see the value, but in terms of preprocessing, there is a difference between `(2-1)` and `1` — 463035818_is_not_an_ai, Jul 27 '17 at 13:30

Toby Speight · Accepted Answer · 2017-07-27T13:41:51.053

Pre-processor macros created using #define are textual substitutions.

The two examples are not equivalent. The first sets BETA to 2-1*2. The second sets BETA to (2-1)*2. It is not correct to claim that ALPHA == 1 as you do, because ALPHA is not a number - ~~it is a free man!~~ it's just a sequence of characters.

When parsed as C or C++, those two expressions are different (the first is the same as 2 - (1*2)).

We can show the difference, by printing the string expansion of BETA as well as evaluating it as an expression:

#ifdef PARENS
#define ALPHA (2-1)
#else
#define ALPHA 2-1
#endif

#define BETA ALPHA*2

#define str(x) str2(x)
#define str2(x) #x

#include <stdio.h>
int main()
{
    printf("%s = %d\n", str(BETA), BETA);
    return 0;
}

Compile the above with and without PARENS defined to see the difference:

(2-1)*2 = 2
2-1*2 = 0

The consequence of this is that when using #define to create macros that expand to expressions, it's generally a good idea to use many more parentheses than you would normally need, as you don't know the context in which your values will be expanded. For example:

#define ALPHA (2-1)
#define BETA ((ALPHA)*2)

Cpp plus 1 · Answer 2 · 2017-07-27T13:39:04.293

3

Order of operations. The first example become 2-1*2, which equals 2-2. The second example, on the other hand, expands to (2-1)*2, which evaluates to 1*2.

In the first example:

#define ALPHA 2-1
#define BETA ALPHA*2

alpha is substituted directly for whatever value you gave it (in this case, 2-1). This leads to BETA expanding into (becoming) 2-1*2, which evaluates to 0, as described above.

In the second example:

#define ALPHA (2-1)
#define BETA ALPHA*2

Alpha (within the definition of BETA) expands into the value it was set to(2-1), which then causes BETA to expand into (2-1)*2 whenever it is used.

In case you're having trouble with order of opeartions, you can always use the acronym PEMDAS to help you (Parenthesis Exponent Multiplication Division Addition Subtraction), which can itself be remembered as "Please Excuse My Dear Aunt Sally". The first operations in the acronym must always be done before the later operations in the acronym (except for multiplication and division (in which you just go from left to right in the equation, since they are considered to have an equal priority, and addition and subtraction (same scenario as multiplication and division).

edited Jul 27 '17 at 13:39

answered Jul 27 '17 at 13:27

Cpp plus 1

990
8
25

This should have been a comment. – user0042 Jul 27 '17 at 13:28
3

@user0042 But it's the answer. – Cpp plus 1 Jul 27 '17 at 13:28
@Cppplus1 If it was the answer - it should have elaborated, why the result becomes `2-1*2`, and what is the difference between those 2 cases. – Algirdas Preidžius Jul 27 '17 at 13:30
2

it is, indeed, the answer. Now please remove the question about the downvote from the body of the answer. Make it a comment if you wish. – Mike Nakis Jul 27 '17 at 13:30
1

This answer is correct, but could benefit from some elaboration. – François Andrieux Jul 27 '17 at 13:31
1

You don't need to elaborate "order of operations". All you need to do is mention it. Then, it can be googled. – Mike Nakis Jul 27 '17 at 13:31
@MikeNakis then you could also say that there is no need for the answer, because it can be googled – 463035818_is_not_an_ai Jul 27 '17 at 13:32
@MikeNakis I, at, least, ask for elaboration of how `#define` works (the functionality of `#define` isn't explained, at all, in this answer), which results in the end result being `2-1*2`, not on order of operations, which happens afterwards. – Algirdas Preidžius Jul 27 '17 at 13:35
I prefer the shorter version of this answer. The answer was good for people who understand preprocessor macros but didn't see or understand that the order of operations was causing the difference. – Class Skeleton Jul 27 '17 at 13:38

score 3 · Answer 3 · answered Jul 27 '17 at 13:32

Macro (#define ...) are only text replacement.

With this version:

#define ALPHA 2-1
#define BETA ALPHA*2

The preprocessor replace BETA by ALPHA*2 then replace ALPHA by 2-1. When the macro expansion is over, BETA is replaced by 2-1*2 which is (due to operator precedence) equal to 2-(1*2)=0

When you add the parenthesis around the "value of ALPHA" (ALPHA doesn’t really have a value since macro are just text replacement), you change the order of evaluation of the operation. Now BETA is replaced by (2-1)*2 which is equal to 2.

Serge · Answer 4 · 2017-07-27T13:43:09.030

macros in c/c++ are just text substitutions, not functions. So the macro is there just to replace a macro name in the program text with its contents before the compiler event tries to analyze the code. So in the first case the compiler will see this:

BETA ==> ALPHA * 2 ==> 2 - 1 * 2 ==> compiler ==> 0
printf("beta=%d\n", BETA); ==> printf("beta=%d\n", 2 - 1 * 2);

In the second

BETA ==> ALPHA * 2 ==> (2 - 1) * 2 ==> compiler ==> 2
printf("beta=%d\n", BETA); ==> printf("beta=%d\n", (2 - 1) * 2);

#define used with operators

4 Answers4

Linked

Related