This is one of three preprocessor operators. The other two operators are the token pasting operator (
##) and the
The behaviour is the same for both C and C++ compilers.
The stringizing operator is used to convert parameters passed to a macro into strings.
The stringizing (
#) operator may only be used with
#define preprocessor directives taking a parameter.
The parameter token immediately to the right of the stringizing operator (ignoring any white space) is transformed by the preprocessor into a string.
#define make_string(x) #x
will convert whatever is passed as parameter
x into a string.
Leading and trailing white space are deleted.
Any white space between the parameter's tokens are collapsed into a single white space character between tokens.
Any conversions necessary to make character literals in the parameter's tokens valid in a string are automatically made. This means that characters like:
" are automatically converted to
If the token is a macro, the macro is not expanded - the macro name is converted into a string. As a consequence, some characters cannot be stringized – notably, the comma (
,) because it is used to delimit parameters and the right parenthesis (
)) because it marks the end of the parameter list.
Given the following macros:
#define make_string(x) #x
#define COMMA ,
the following uses:
make_string(twas brillig); make_string( twas brillig ); make_string("twas" "brillig"); make_string(twas COMMA brillig);
get expanded into:
// no surprise here "twas brillig" // leading and trailing spaces were trimmed, // space between words was compressed to a single space character "twas brillig" // the quotes were automatically converted "\"twas\" \"brillig\"" // the macro COMMA was not expanded "twas COMMA brillig"
In C99 and the upcoming C++0x languages, you can use a variadic macro to pass commas to the stringizing operator.
#define make_string(...) # __VA_ARGS__
Since __VA_ARGS__ does not process the comma separator, you can pass it to the stringizing operator. However, you still cannot pass the right parenthesis.
Stringizing a Single Character
Sometimes you want to create a character literal. Unfortunately, the language does not specify a charizing operator (although, the Microsoft compiler does provide the non-standard operator
#@ for charizing a single character).
However, you can simulate a charizing operator as follows:
#define CHARIZE(x) #x
What this does is stringize whatever is passed as parameter
x and then addresses the first character - effectively acting as though the parameter had been charized. This works in most places a character literal is expected, but not all.
Please consider sharing this article if you liked it or found it useful.
You may use one of the buttons below or share using your own favourite media.
Please do not republish this article on your website. You may publish a short excerpt and provide a link back to the original article.