What does "#define STR(a) #a" do?

I'm reading the phoneME's source code. It's a FOSS JavaME implementation. It's written in C++, and I stumbled upon this:

// Makes a string of the argument (which is not macro-expanded)
#define STR(a) #a

I know C and C++, but I never read something like this. What does the # in #a do?

Also, in the same file, there's:

// Makes a string of the macro expansion of a
#define XSTR(a) STR(a)

I mean, what's the use of defining a new macro, if all it does is calling an existing macro?

The source code is in https://phoneme.dev.java.net/source/browse/phoneme/releases/phoneme_feature-mr2-rel-b23/cldc/src/vm/share/utilities/GlobalDefinitions.hpp?rev=5525&view=markup. You can find it with a CTRL+F.

Solution 1:

In the first definition, #a means to print the macro argument as a string. This will turn, e.g. STR(foo) into "foo", but it won't do macro-expansion on its arguments.

The second definition doesn't add anything to the first, but by passing its argument to another macro, it forces full macro expansion of its argument. So XSTR(expr) creates a string of expr with all macros fully expanded.

Solution 2:

# is the stringizing operator. The preprocessor makes a string out of the parameter.

Say you have:

STR(MyClass);

It would be preprocessed as:

"MyClass";

The level of indirection (using XSTR()) has to do with macro expansion rules.

Solution 3:

First, you should know that this pair of macros is actually fairly common. The first does exactly what the comment says -- it turns an argument into a string by enclosing it in double quotes.

The second is used to cause macro expansion of the argument. You typically use them together something like this:

#define a value_a

printf("%s", XSTR(a));

The macro expansion will expand a out to string_a, and the stringify will turn that into a string, so the output will be value_a.