Stringification – how does it work?

by

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.

More Related Contents:

  1. Why are preprocessor macros evil and what are the alternatives?
  2. C++ preprocessor __VA_ARGS__ number of arguments
  3. How do I see a C/C++ source file after preprocessing in Visual Studio?
  4. How to detect reliably Mac OS X, iOS, Linux, Windows in C preprocessor? [duplicate]
  5. Can we have recursive macros?
  6. How, exactly, does the double-stringize trick work?
  7. C++ preprocessor #define-ing a keyword. Is it standards conforming?
  8. When are C++ macros beneficial? [closed]
  9. Namespaces in C
  10. Representing big numbers in source code for readability?
  11. How to identify platform/compiler from preprocessor macros?
  12. C/C++, can you #include a file into a string literal? [duplicate]
  13. Portability of #warning preprocessor directive
  14. Opposite of C preprocessor “stringification”
  15. C/C++ macro/template blackmagic to generate unique name
  16. Difference between Enum and Define Statements
  17. What’s the difference between the WIN32 and _WIN32 defines in C++
  18. Somehow register my classes in a list
  19. What does “#define STR(a) #a” do?
  20. Can I redefine a C++ macro then define it back?
  21. Is the backslash acceptable in C and C++ #include directives?
  22. “No newline at end of file” compiler warning
  23. How to test if preprocessor symbol is #define’d but has no value?
  24. How does C++ Preprocessors work?
  25. C++ #include semantics
  26. What is the NDEBUG preprocessor macro used for (on different platforms)?
  27. Is there a way to do a #define inside of another #define?
  28. How can I see the output of the Visual C++ preprocessor? [duplicate]
  29. Are Variadic macros nonstandard?
  30. #ifdef vs #if – which is better/safer as a method for enabling/disabling compilation of particular sections of code?

Leave a Comment