使用唯一的预处理器进行字符串连接？

Question

Is it possible to concatenate quoted string literals outside of the language (C++, in this case)?

That is, can I define MY_MACRO(a,b,c) and use it thus:

MY_MACRO("one", "two", "three")

and have it expand to: "onetwothree" ?

The use case is to apply an attribute and its message to, say, a function signature, like so:

MY_ATTRIBUTE_MACRO("this", "is", "the reason") int foo() { return 99; }

and it would result in:

[[nodiscard("thisisthe reason")]] int foo() { return 99; }

Answer 1

The language already does string concatenation!

This:

"hi" "James"

becomes just one string literal.

That means you do not need any preprocessor tricks for this at all.

---

You need only employ this in the output of your macro:

#define MY_ATTRIBUTE_MACRO(x,y,z) [[nodiscard(x y z)]]

Now this:

MY_ATTRIBUTE_MACRO("this", "is", "the reason") int foo() { return 99; }

is this:

[[nodiscard("this" "is" "the reason")]] int foo() { return 99; }

which is actually already what you wanted, because of the implicit string concatenation (which happens after macro expansion):

[[nodiscard("thisisthe reason")]] int foo() { return 99; }

---

Translation phase 4 :

[lex.phases]/4: Preprocessing directives are executed, macro invocations are expanded , and _Pragma unary operator expressions are executed. If a character sequence that matches the syntax of a universal-character-name is produced by token concatenation, the behavior is undefined. A #include preprocessing directive causes the named header or source file to be processed from phase 1 through phase 4, recursively. All preprocessing directives are then deleted.

Translation phase 6 :

[lex.phases]/6: Adjacent string literal tokens are concatenated.

Answer 2

I'm not sure what you mean by "outside the language" but, in C++, any string literals separated just by whitespace are implicitly concatenated into one. Thus, your MY_MACRO definition is actually very simple:

#include <iostream>

#define MY_MACRO(a, b, c) a b c

int main()
{
    std::cout << MY_MACRO("one", "two", "three") << std::endl;
    return 0;
}

The output from this short program is what you asked for: onetwothree .

---

Note: As a matter of curiosity/interest, it is normally recommended to enclose macro arguments in parentheses, in the definition part, so as to avoid unwanted side effects of the evaluation. However, in this case, using such parentheses won't work, and breaks the implicit concatenation:

#define MY_MACRO(a, b, c) (a) (b) (c) // Broken!