C/C++ preprocessing ambiguity

Question

On executing the following code using 'Macro Definitions Set 1', I encounter the error "C2065: 'C1' : undeclared identifier".

While using 'Macro Definitions Set 2', the code runs to give an output of 2.

I am guessing it has something to do with preprocessor tokenization. Please Explain.

#include <iostream>

// Macro Definitions Set 1
#define A       1
#define D(n)    B(n)
#define B(n)    C##n
#define CA      2

// Macro Definitions Set 2
//#define A     1
//#define D(n)  C##n
//#define CA        2

int main ()
{

    printf ("%d", D(A));
}

A similar question with the same answer here: http://stackoverflow.com/a/2751891/6210 — MSN, Nov 30 '11 at 05:17

score 3 · Accepted Answer · answered Nov 30 '11 at 05:20

The macro parameter is substituted unless it is before or after ##, or after #.

So in Set 1, D(A) becomes B(1) after substitution of D(n), which is substituted to C1 after rescan.

In Set 2, D(A) becomes CA, where A is not substituted as it is after ##, and CA becomes 2 after rescan.

score 2 · Answer 2 · answered Nov 30 '11 at 05:24

With your first set of macros:

#define A       1
#define D(n)    B(n)
#define B(n)    C##n
#define CA      2

D(A) is evaluated by performing macro replacement on A and then substituting it into the replacement list for D(n). The macro replacement results in 1, so this gives B(1). B(1) is then recursively evaluated, giving C##1 which is concatenated to the preprocessing token C1.

With your second set of macros:

#define A     1
#define D(n)  C##n
#define CA    2

When D(A) is evaluated, macro replacement on the argument n is not performed, because it is prefixed by ##. This gives C##A, which results in the preprocessing token CA. This is then re-examined for macros to replace, which results in 2.

score 0 · Answer 3 · answered Nov 30 '11 at 05:20

You need to go through each stage during the resolution. Basically, the preprocessor does an iterative search and replace until it runs out of tokens (it can be more complex, but for current purposes, that's what happens). It goes left to right on each line.

Now, what happens using set 2:

printf("%d", D(A)); <- first preprocessor token found is D(A), so:
printf("%d", CA);
printf("%d", 2);

What appears to be happening with set 1:

printf("%d", D(A)); <- first preprocessor token found is D(A), so:
printf("%d", B(A)); <- now, the next token found is A
printf("%d", B(1));
printf("%d", C1); <- and error

The issue is that the replacement occurs, then the preprocessor finds the A next (perhaps not restarting the line) and performs another replacement. Then it does go over it again, but finds B(1).

To test this, you can just leave off some of the later declarations and preprocess to a file. That will show you exactly what's happening.

The arguments is processed before the whole function style macro, so in `D(A)`, first `A` is substituted which `1` (as no `#` or `##` exists in the expansion), then `D(1)` becomes `B(1)`. — fefe, Nov 30 '11 at 05:24
You have not mentioned the `##` operator, which is the key to this - it is the `##` operator that stops the `A` from turning into a `1`. — caf, Nov 30 '11 at 05:27

C/C++ preprocessing ambiguity

3 Answers3