61

I know that:

#define foo 4  
#define str(s) #s

with str(foo) writes out: "foo", because stringify is executed first of text expansion, but this:

 #define xstr(s) str(s)
 #define str(s) #s
 #define foo 4

with xstr(foo) writes out: "4".

Why? What are the steps involved in the process?

Lundin
  • 195,001
  • 40
  • 254
  • 396
Marco A.
  • 43,032
  • 26
  • 132
  • 246

2 Answers2

65

The relevant steps of macro expansion are (per C 2011 [n1570] 6.10.3.1 and C++ 1998 16.3.1):

  1. Process tokens that are preceded by # or ##.
  2. Apply macro replacement to each argument.
  3. Replace each parameter with the corresponding result of the above macro replacement.
  4. Rescan for more macros.

Thus, with xstr(foo), we have:

  1. The replacement text, str(s), contains no # or ##, so nothing happens.
  2. The argument foo is replaced with 4, so it is as if xstr(4) had been used.
  3. In the replacement text str(s), the parameter s is replaced with 4, producing str(4).
  4. str(4) is rescanned. (The resulting steps produce ”4”.)

Note that the problem with str(foo) is that step 2, which would replace foo with 4, comes after step 1, which changes the argument to a string. In step 1, foo is still foo; it has not been replaced with 4, so the result is ”foo”.

This is why a helper macro is used. It allows us to get a step 2 performed, then use another macro to perform step 1.

Eric Postpischil
  • 195,579
  • 13
  • 168
  • 312
  • 3
    At last! I finally understood why this works like this, after reading this answer. I even was using it correctly by intuition, but couldn't come to the rule. The `stringify` macro comes up in many places (e.g. appending `__LINE__` to identifier - to force it to be expanded and not left as `__LINE__`, in that case you'll use `##` instead of `#`), or - more recently needed to pass arguments to GCC's `_Pragma()` macro (intrinsic?), which accepts a quoted string, so you may need: `#define my_pragma(arg) _Pragma(stringify("blah " #arg " blah2"))`. – Tomasz Gandor Jan 17 '14 at 21:50
  • #define PE(BZL,YY) printf("ERROR - " #BZL ": result: 0x%08x!", YY); Doing:int variable1=1; PE(Test1,variable1); --> Results printing: ERROR - Test1: result: 0x1! – Joniale Jun 04 '20 at 09:09
16

First case

  1. Evaluate str(foo): Substitute str(foo) with #foo, ie "foo"

Second case

  1. Evaluate xstr(foo): Substitute xstr(foo) with str(<foo-value>), ie str(4)
  2. Evaluate str(4): Substitute str(4) with #4, ie "4"

Generally,

preprocessor evaluates macro-functions expanding macro-variables, until it is nothing to evaluate:

If you define

#define xstr(s) str(s) + 1
#define str(s) s + 1

in the following code

#define foo 4

int main()
{
    std::cout << str(foo) << '\n' 
              << xstr(foo) << '\n' ;

}

it would evaluate like

First string

  1. Substitute str(foo) with <foo-value> + 1, ie 4 + 1
  2. Nothing more to substitute. Finishing.

And result is 4 + 1

Second string

  1. Substitute xstr(foo) with str(<foo-value>) + 1, ie str(4) + 1
  2. Substitute str(4) with <4-value> + 1, ie 4 + 1
  3. Nothing more to substitute.

And result is 4 + 1 + 1

Community
  • 1
  • 1
Lol4t0
  • 12,444
  • 4
  • 29
  • 65
  • I still don't understand.. First case: 1) Stringify foo 2) Expand, I now have foo. Second case: 1) Stringify, there's nothing to stringify.. 2) expand, I now have str(s) 3) stringify, now I have str(s) foo 4) Expand, now I have foo. Why is it different?? – Marco A. Jun 07 '13 at 17:52
  • @DavidKernin, Well, _do_ you understand, that 'stringify' operation is `#`? It is only one step. – Lol4t0 Jun 07 '13 at 17:56
  • @DavidKernin, this just not so smart, as you believe. It is pretty dumb. It just expands everything. – Lol4t0 Jun 07 '13 at 18:00
  • 1
    I got it, it's like a stack of functions.. it just keeps substituting until it encounters a # then stops the substitution. Returning from these "functions" substitutions continue if there is no other #. – Marco A. Jun 07 '13 at 18:05