How Does Macro Expansion Order Affect Stringification in C Preprocessing?

Unveiling the Magic of Stringification

In the realm of programming, stringification stands as a versatile technique that allows macros to dynamically generate strings based on their arguments. Key to understanding how this process unfolds is the meticulous order in which macro expansion occurs.

Consider the following macro definition:

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

When str(foo) is evaluated, it results in the expansion of #s to "foo" because the stringify operation (#) takes precedence over textual expansion. However, when you introduce additional layers of macro indirection, the order of operations becomes crucial.

The Case of xstr(foo)

Define the macro xstr(s) as:

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

Applying this macro to xstr(foo) produces an unexpected outcome: "4". The key to unraveling this mystery lies in the following steps of macro expansion:

1. Preprocess tokens prefixed with # or ##.
2. Expand macros within macro arguments.
3. Substitute macro parameters with corresponding replacement text.
4. Rescan the result for further macro expansions.

When xstr(foo) is processed:

1. # in xstr(s) is identified.
2. foo is replaced with 4.
3. #s in str(s) is swapped with #4.
4. str(4) is now rescanned.

Since #4 is a string literal, it resolves to "4". Therefore, xstr(foo) evaluates to "4" rather than "foo" because the stringification operation takes effect after textual expansion.

A Lesson in Macro Order

This seemingly counterintuitive result highlights the importance of macro order. To avoid such ambiguities, it is often recommended to employ a helper macro to execute one step before applying the stringify operation. This ensures the desired outcome by clearly defining the order of operations.

The above is the detailed content of How Does Macro Expansion Order Affect Stringification in C Preprocessing?. For more information, please follow other related articles on the PHP Chinese website!