What is the purpose of the ## operator in C++, and what is it called?

Question

I was looking through the DXUTCore project that comes with the DirectX March 2009 SDK, and noticed that instead of making normal accessor methods, they used macros to create the generic accessors, similar to the following:

#define GET_ACCESSOR( x, y )  inline x Get##y()  { DXUTLock l; return m_state.m_##y;};
...

GET_ACCESSOR( WCHAR*, WindowTitle );

It seems that the ## operator just inserts the text from the second argument into the macro to create a function operating on a variable using that text. Is this something that is standard in C++ (i.e. not Microsoft specific)? Is its use considered good practice? And, what is that operator called?

Answer 1

It's a preprocessing operator that concatenates left and right operands (without inserting whitespace). I don't think it's Microsoft specific.

Answer 2

Token-pasting operator, used by the pre-processor to join two tokens into a single token.

Answer 3

it's the concatenation for macro arguments i.e.

GET_ACCESSOR (int, Age);

will be expended to

inline int GetAge()  { DXUTLock l; return m_state.m_Age;};

Answer 4

This isn't Standard C++, it's Standard C. Check out this Wikipedia article.

And is it a good practice? In general, I hate pre-processor macros and think they're as bad as (if not worse than) Goto.

Edit: Apparently I'm being misunderstood by what I meant by "This isn't Standard C++, it's Standard C". Many people are reading the first phrase and failing to read the second. My intent is to point out that macros were inherited by C++ from C.

Answer 5

As Mehrdad said, it concatenates the operands, like:

#define MyMacro(A,B) A ## B
MyMacro(XYZ, 123) // Equivalent to XYZ123

Note that MISRA C suggests that this operand (and the # 'stringify' operand) should not be used due to the compiler dependent order of calculation.

Answer 6

It is token pasting operator allowed by Standard C++ (see 16.3.3 for details). As for good practice: using macro is not a good practice IMHO (in C++).

Answer 7

This is also standard C++, contrary to what Raldolpho stated.

Here is the relevant information:

16.3.3 The ## operator [cpp.concat]

1 A ## preprocessing token shall not occur at the beginning or at the end of a replacement list for either form of macro definition.

2 If, in the replacement list, a parameter is immediately preceded or followed by a ## preprocessing token, the parameter is replaced by the corresponding argument’s preprocessing token sequence.

3 For both object-like and function-like macro invocations, before the replacement list is reexamined for more macro names to replace, each instance of a ## preprocessing token in the replacement list (not from an argument) is deleted and the preceding preprocessing token is concatenated with the following preprocessing token. If the result is not a valid preprocessing token, the behavior is undefined. The resulting token is available for further macro replacement. The order of evaluation of ## operators is unspecified.