virgola in C/C++ macro

Question

Supponiamo di avere una macro come questo

#define FOO(type,name) type name 

che potremmo usare come

FOO(int, int_var); 

Ma non sempre nel modo più semplice che:

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

Naturalmente potremmo fare:

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

che non è molto ergonomico. Devono essere affrontate anche le incompatibilità di tipo. Qualche idea su come risolvere questo problema con la macro?

Answer 1

Perché le parentesi angolari possono anche rappresentare (o verificarsi) il confronto operatori <, >, <= e >=, l'espansione macro non può ignorare le virgole tra parentesi angolari come fa tra parentesi. (Questo è un problema anche per parentesi quadre e graffe, anche se quelli normalmente si verificano come coppie bilanciate.) È possibile racchiudere l'argomento macro in parentesi:

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

Il problema è quindi che il parametro rimane racchiusa tra parentesi all'interno della macro espansione, che impedisce di essere letto come un tipo nella maggior parte dei contesti.

Un bel trucco per aggirare questo è che in C++, è possibile estrarre un TypeName da un nome di tipo tra parentesi usando un tipo di funzione:

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

Perché la formazione di tipi di funzione ignora parentesi in più, è possibile utilizzare questa macro con o senza parentesi in cui il nome del tipo non include una virgola:

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

In C, naturalmente, questo non è necessario perché i nomi di tipo non possono contenere virgole fuori parentesi. Così, per una macro cross-language si può scrivere:

#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 

Answer 2

Se il preprocessore supporta le macro variadic:

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

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

In caso contrario, è un po 'più noioso:

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

Answer 3

Ci sono almeno due modi per farlo. In primo luogo, è possibile definire una macro che prende più argomenti:

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

se si fa questo si potrebbe scoprire che si finisce per definire più macro per gestire più argomenti.

In secondo luogo, si può mettere tra parentesi l'argomento:

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

se si fa questo si potrebbe scoprire che le parentesi aggiuntive rovinare la sintassi del risultato.

Answer 4

La semplice risposta è che non è possibile. Questo è un effetto collaterale della scelta di <...> per gli argomenti del modello; i modelli < e > vengono visualizzati anche in contesti sbilanciati, pertanto il meccanismo macro non può essere esteso per gestirli come gestisce le parentesi. (Alcuni membri del comitato avevano sostenuto un diverso token, ad esempio (^...^), ma non erano in grado di convincere la maggior parte dei problemi utilizzando <...>.)

Answer 5

Ciò è possibile con P99:

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

Il codice strisce sopra in modo efficace solo l'ultima virgola nella lista degli argomenti. Verificare con clang -E (P99 richiede un compilatore C99).

Answer 6

Se non è possibile usare le parentesi e non ti piace la soluzione SINGLE_ARG di Mike, basta definire una virgola:

#define COMMA , 

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

Questo aiuta anche se si vuole stringa i alcuni degli argomenti di macro, come 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); 
} 

che stampa std::map<int , int> has typeid name "St3mapIiiSt4lessIiESaISt4pairIKiiEEE".

Answer 7

Basta definire FOO come

#define UNPACK(...) __VA_ARGS__ 

#define FOO(type, name) UNPACK type name 

Poi invocarla sempre con parentesi attorno al argomento di tipo, per esempio

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

Può essere una buona idea esemplificare le invocazioni in un commento sulla definizione della macro.