Przecinek w makrze C / C ++

Powiedzmy, że mamy takie makro

#define FOO(type,name) type name

Którego moglibyśmy użyć

FOO(int, int_var);

Ale nie zawsze tak prosto:

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

Oczywiście mogliśmy zrobić:

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

co nie jest zbyt ergonomiczne. Niezgodności typu Plus muszą zostać rozwiązane. Masz jakiś pomysł, jak rozwiązać ten problem za pomocą makra?

Ponieważ wsporniki kątowe może także oznaczać (lub występują w) operatorów porównania <, >, <=i >=, makro rozszerzeń nie ignorować przecinki wewnątrz wsporników kątowych, jak to czyni w nawiasach. (Jest to również problem w przypadku nawiasów kwadratowych i nawiasów klamrowych, mimo że zwykle występują one jako zrównoważone pary). Możesz umieścić argument makro w nawiasach:

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

Problem polega na tym, że parametr pozostaje w nawiasach wewnątrz rozwinięcia makra, co uniemożliwia odczytanie go jako typu w większości kontekstów.

Fajną sztuczką do obejścia tego jest to, że w C ++ możesz wyodrębnić nazwę typu z nazwy typu w nawiasach za pomocą typu funkcji:

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);

Ponieważ tworzenie typów funkcji ignoruje dodatkowe nawiasy, możesz użyć tego makra z nawiasami lub bez, gdzie nazwa typu nie zawiera przecinka:

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

W C oczywiście nie jest to konieczne, ponieważ nazwy typów nie mogą zawierać przecinków poza nawiasami. Tak więc dla makra międzyjęzykowego możesz napisać:

#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

Jeśli nie możesz użyć nawiasów i nie podoba ci się rozwiązanie SINGLE_ARG autorstwa Mike'a, po prostu zdefiniuj PRZECINEK:

#define COMMA ,

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

Jest to również pomocne, jeśli chcesz zdefiniować niektóre argumenty makr, jak w

#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);
}

który drukuje std::map<int , int> has typeid name "St3mapIiiSt4lessIiESaISt4pairIKiiEEE".

Jeśli Twój preprocesor obsługuje makra wariadyczne:

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

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

W przeciwnym razie jest to trochę bardziej uciążliwe:

#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);

Po prostu zdefiniuj FOOjako

#define UNPACK( ... ) __VA_ARGS__

#define FOO( type, name ) UNPACK type name

Następnie wywołaj go zawsze z nawiasami wokół argumentu typu, np

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

Oczywiście dobrym pomysłem może być zilustrowanie wywołań w komentarzu do definicji makra.

Można to zrobić na co najmniej dwa sposoby. Najpierw możesz zdefiniować makro, które przyjmuje wiele argumentów:

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

jeśli to zrobisz, może się okazać, że w końcu zdefiniujesz więcej makr do obsługi większej liczby argumentów.

Po drugie, możesz umieścić argument w nawiasach:

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

jeśli to zrobisz, może się okazać, że dodatkowe nawiasy zepsują składnię wyniku.

Jest to możliwe z P99 :

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

Powyższy kod skutecznie usuwa tylko ostatni przecinek na liście argumentów. Sprawdź za pomocą clang -E(P99 wymaga kompilatora C99).

Prosta odpowiedź brzmi: nie możesz. Jest to efekt uboczny wyboru <...>argumentów dla szablonu; <a >także pojawiają się w kontekstach niesymetrycznych więc makro mechanizm nie mógł być przedłużony do obsługi ich jak obsługuje nawiasów. (Niektórzy członkowie komitetu opowiadali się za innym tokenem, powiedzmy (^...^), ale nie byli w stanie przekonać większości problemów za pomocą <...>.)