What is the compiler seeing with this macro? [clos

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.

Closed 7 years ago.

Consider this:

  #define STRINGIFY(A) #A

If I then later write:

 STRINGIFY(hello)

Is the compiler actually seeing this:

 #hello

I think it is that additional hash in front of #A that is confusing me.

Answer 1

No, the compiler will put the argument between quotes, resulting in this:

"hello"

However, beware that macro substitution doesn't take place near # and ##, so if you really need to stringify the argument (even if it's another macro) it's better to write two macros, the first one to expand the argument and the other one to add quotes:

#define STRINGIFY(x) STRINGIFY_AUX(x)
#define STRINGIFY_AUX(x) #x

Or more generally, if you're compiler supports variadic macros (introduced in C99):

#define STRINGIFY(...) STRINGIFY_AUX(__VA_ARGS__)
#define STRINGIFY_AUX(...) #__VA_ARGS__

If you really need a function-like macro that paste a # at the beginning of the argument, I think you need it to generate a string (otherwise you'd make an invalid token for the compiler), so you could simple generate two string literals that the compiler will "paste":

#include <stdio.h>

#define STRINGIFY(...) STRINGIFY_AUX(__VA_ARGS__)
#define STRINGIFY_AUX(...) #__VA_ARGS__

int main(void)
{
  puts(STRINGIFY(#) STRINGIFY(hello));
}

The main body will look like this in the preprocessor output:

puts("#" "hello");

I hope this is not an obscure corner of the preprocessor that results in undefined behavior, but it shouldn't be a problem since we're not generating another preprocessor instruction.

Answer 2

You can test it yourself using the -E (*) flag (with gcc/g++):

test.cpp

#define STRINGIFY(A) #A

int main(int argc, const char *argv[])
{
    STRINGIFY(hello);
    return 0;
}

Output of g++ test.cpp -E

# 1 "test.cpp"
# 1 "<command-line>"
# 1 "test.cpp"


int main(int argc, const char *argv[])
{
    "hello";
    return 0;
}

_{(*): If you use the -E option, nothing is done except preprocessing. - GCC Options Controlling the Preprocessor}

Answer 3

Found good, simple explanation of using hash in preprocessor here:

http://www.cplusplus.com/doc/tutorial/preprocessor/

Answer 4

What the compiler sees is this:

"hello"

The hash is preprocessor-only token.

Single hash stringifies the argument.

#define STRINGIFY(x) #x
STRINGIFY(hello)

gets replaced by

"hello"

Double hash concatenates the tokens:

#define CAT(a, b) a##b
#define _STRINGIFY(x) #x
#define STRINGIFY(x) _STRINGIFY(x)
STRINGIFY(CAT(hello,world))

gets replaced by this:

_STRINGIFY(helloworld)

and then by this:

"helloworld"

EDIT: As Pubby pointed out, the example was wrong, the macro replacement doesn't work that way, but now I corrected it.