Komma im C / C ++ - Makro

Angenommen, wir haben ein solches Makro

#define FOO(type,name) type name

Was wir gerne gebrauchen könnten

FOO(int, int_var);

Aber nicht immer so einfach:

FOO(std::map<int, int>, map_var); // error: macro "FOO" passed 3 arguments, but takes just 2

Natürlich könnten wir tun:

 typedef std::map<int, int> map_int_int_t;
 FOO(map_int_int_t, map_var); // OK

das ist nicht sehr ergonomisch. Plus-Typ-Inkompatibilitäten müssen behoben werden. Irgendeine Idee, wie man das mit einem Makro löst?

Da Klammern Winkel auch (oder treten in) die Vergleichsoperatoren darstellen können <, >, <=und >=können Makroerweiterung ignorieren keine Kommas innerhalb spitzen Klammern , wie es in Klammern der Fall ist. (Dies ist auch ein Problem für eckige Klammern und Klammern, obwohl diese normalerweise als ausgeglichene Paare auftreten.) Sie können das Makroargument in Klammern setzen:

FOO((std::map<int, int>), map_var);

Das Problem ist dann, dass der Parameter innerhalb der Makroerweiterung in Klammern bleibt, wodurch verhindert wird, dass er in den meisten Kontexten als Typ gelesen wird.

Ein guter Trick, um dies zu umgehen, besteht darin, dass Sie in C ++ einen Typnamen aus einem in Klammern gesetzten Typnamen mithilfe eines Funktionstyps extrahieren können:

template<typename T> struct argument_type;
template<typename T, typename U> struct argument_type<T(U)> { typedef U type; };
#define FOO(t,name) argument_type<void(t)>::type name
FOO((std::map<int, int>), map_var);

Da beim Bilden von Funktionstypen zusätzliche Klammern ignoriert werden, können Sie dieses Makro mit oder ohne Klammern verwenden, wenn der Typname kein Komma enthält:

FOO((int), int_var);
FOO(int, int_var2);

In C ist dies natürlich nicht erforderlich, da Typnamen keine Kommas außerhalb von Klammern enthalten dürfen. Für ein sprachübergreifendes Makro können Sie also schreiben:

#ifdef __cplusplus__
template<typename T> struct argument_type;
template<typename T, typename U> struct argument_type<T(U)> { typedef U type; };
#define FOO(t,name) argument_type<void(t)>::type name
#else
#define FOO(t,name) t name
#endif

Wenn Sie keine Klammern verwenden können und Mikes SINGLE_ARG-Lösung nicht mögen, definieren Sie einfach ein COMMA:

#define COMMA ,

FOO(std::map<int COMMA int>, map_var);

Dies ist auch hilfreich, wenn Sie einige der Makroargumente wie in

#include <cstdio>
#include <map>
#include <typeinfo>

#define STRV(...) #__VA_ARGS__
#define COMMA ,
#define FOO(type, bar) bar(STRV(type) \
    " has typeid name \"%s\"", typeid(type).name())

int main()
{
    FOO(std::map<int COMMA int>, std::printf);
}

welche druckt std::map<int , int> has typeid name "St3mapIiiSt4lessIiESaISt4pairIKiiEEE".

Wenn Ihr Präprozessor verschiedene Makros unterstützt:

#define SINGLE_ARG(...) __VA_ARGS__
#define FOO(type,name) type name

FOO(SINGLE_ARG(std::map<int, int>), map_var);

Ansonsten ist es etwas langweiliger:

#define SINGLE_ARG2(A,B) A,B
#define SINGLE_ARG3(A,B,C) A,B,C
// as many as you'll need

FOO(SINGLE_ARG2(std::map<int, int>), map_var);

Einfach definieren FOOals

#define UNPACK( ... ) __VA_ARGS__

#define FOO( type, name ) UNPACK type name

Rufen Sie es dann immer in Klammern um das Typargument auf, z

FOO( (std::map<int, int>), map_var );

Es kann natürlich eine gute Idee sein, die Aufrufe in einem Kommentar zur Makrodefinition zu veranschaulichen.

Es gibt mindestens zwei Möglichkeiten, dies zu tun. Zunächst können Sie ein Makro definieren, das mehrere Argumente akzeptiert:

#define FOO2(type1, type2, name) type1, type2, name

Wenn Sie dies tun, werden Sie möglicherweise mehr Makros definieren, um mehr Argumente zu verarbeiten.

Zweitens können Sie das Argument in Klammern setzen:

#define FOO(type, name) type name
F00((std::map<int, int>) map_var;

Wenn Sie dies tun, stellen Sie möglicherweise fest, dass die zusätzlichen Klammern die Syntax des Ergebnisses durcheinander bringen.

Dies ist mit P99 möglich :

#include "p99/p99.h"
#define FOO(...) P99_ALLBUTLAST(__VA_ARGS__) P99_LAST(__VA_ARGS__)
FOO()

Der obige Code entfernt effektiv nur das letzte Komma in der Argumentliste. Überprüfen Sie mit clang -E(P99 erfordert einen C99-Compiler).

Die einfache Antwort ist, dass Sie nicht können. Dies ist ein Nebeneffekt der Auswahl von <...>Vorlagenargumenten. Das <und wird >auch in unausgeglichenen Kontexten angezeigt, sodass der Makromechanismus nicht so erweitert werden kann, dass er sie wie Klammern behandelt. (Einige der Komiteemitglieder hatten sich beispielsweise für ein anderes Zeichen ausgesprochen (^...^), konnten jedoch die Mehrheit der Probleme nicht überzeugen <...>.)