Virgola nella macro C / C ++

Supponiamo di avere una macro come questa

#define FOO(type,name) type name

Quale potremmo usare come

FOO(int, int_var);

Ma non sempre così semplicemente:

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

Ovviamente potremmo fare:

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

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

Poiché staffe angolari possono anche rappresentare (o verificarsi) gli operatori di confronto <, >, <=e >=, macro espansione non può ignorare virgole all'interno angolari come appare tra parentesi. (Questo è anche un problema per le parentesi quadre e le parentesi graffe, anche se di solito si presentano come coppie bilanciate.) Puoi racchiudere l'argomento macro tra parentesi:

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

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

Un bel trucco per risolvere questo problema è che in C ++ puoi estrarre un nome di tipo 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);

Poiché la formazione dei tipi di funzione ignora le parentesi aggiuntive, puoi 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, ovviamente, questo non è necessario perché i nomi dei tipi non possono contenere virgole fuori parentesi. Quindi, per una macro multilingue puoi 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

Se non puoi usare le parentesi e non ti piace la soluzione SINGLE_ARG di Mike, definisci semplicemente un COMMA:

#define COMMA ,

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

Questo aiuta anche se vuoi stringere alcuni degli argomenti 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".

Se il tuo preprocessore supporta le macro variadiche:

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

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

Altrimenti, è 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);

Basta definire FOOcome

#define UNPACK( ... ) __VA_ARGS__

#define FOO( type, name ) UNPACK type name

Quindi invocalo sempre tra parentesi attorno all'argomento del tipo, ad es

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

Ovviamente può essere una buona idea esemplificare le invocazioni in un commento sulla definizione macro.

Ci sono almeno due modi per farlo. Innanzitutto, puoi definire una macro che accetta più argomenti:

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

se lo fai potresti scoprire che finisci per definire più macro per gestire più argomenti.

Secondo, puoi mettere parentesi attorno all'argomento:

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

se lo fai potresti scoprire che le parentesi extra rovinano la sintassi del risultato.

Questo è possibile con P99 :

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

Il codice precedente rimuove efficacemente solo l'ultima virgola nell'elenco degli argomenti. Verificare con clang -E(P99 richiede un compilatore C99).

La semplice risposta è che non puoi. Questo è un effetto collaterale della scelta di <...>per gli argomenti del modello; l' <e >appaiono anche in contesti non bilanciati in modo che il meccanismo di macro non potrebbe essere esteso a gestirli come gestisce parentesi. (Alcuni membri del comitato avevano sostenuto per un token diverso, ad esempio (^...^), ma non sono stati in grado di convincere la maggior parte dei problemi nell'uso <...>.)