Coma en macro C / C ++

Digamos que tenemos una macro como esta

#define FOO(type,name) type name

Que podríamos usar como

FOO(int, int_var);

Pero no siempre tan simple como eso:

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

Por supuesto que podríamos hacer:

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

que no es muy ergonómico. Deben tratarse las incompatibilidades de tipo plus. ¿Alguna idea de cómo resolver esto con macro?

Debido corchetes angulares también pueden representar (o producirse en) los operadores de comparación <, >, <=y >=, la expansión macro no puede ignorar comas dentro de corchetes angulares como lo hace dentro de paréntesis. (Esto también es un problema para los corchetes y llaves, aunque estos suelen aparecer como pares equilibrados). Puede encerrar el argumento macro entre paréntesis:

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

El problema es entonces que el parámetro permanece entre paréntesis dentro de la expansión de la macro, lo que evita que se lea como un tipo en la mayoría de los contextos.

Un buen truco para solucionar esto es que en C ++, puede extraer un nombre de tipo de un nombre de tipo entre paréntesis utilizando un tipo de función:

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

Debido a que la formación de tipos de función ignora los paréntesis adicionales, puede usar esta macro con o sin paréntesis donde el nombre del tipo no incluye una coma:

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

En C, por supuesto, esto no es necesario porque los nombres de tipo no pueden contener comas fuera de paréntesis. Entonces, para una macro en varios idiomas, puede escribir:

#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

Si no puede usar paréntesis y no le gusta la solución SINGLE_ARG de Mike, simplemente defina una COMMA:

#define COMMA ,

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

Esto también ayuda si desea encadenar algunos de los argumentos macro, como en

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

que imprime std::map<int , int> has typeid name "St3mapIiiSt4lessIiESaISt4pairIKiiEEE".

Si su preprocesador admite macros variadic:

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

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

De lo contrario, es un poco más tedioso:

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

Solo define FOOcomo

#define UNPACK( ... ) __VA_ARGS__

#define FOO( type, name ) UNPACK type name

Luego invocalo siempre entre paréntesis alrededor del argumento de tipo, por ejemplo

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

Por supuesto, puede ser una buena idea ejemplificar las invocaciones en un comentario sobre la definición de macro.

Hay al menos dos formas de hacer esto. Primero, puede definir una macro que tome múltiples argumentos:

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

si lo hace, es posible que termine definiendo más macros para manejar más argumentos.

En segundo lugar, puede poner paréntesis alrededor del argumento:

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

si lo hace, puede encontrar que los paréntesis adicionales arruinan la sintaxis del resultado.

Esto es posible con P99 :

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

El código anterior elimina efectivamente solo la última coma en la lista de argumentos. Verifique con clang -E(P99 requiere un compilador C99).

La respuesta simple es que no puedes. Este es un efecto secundario de la elección de <...>argumentos de plantilla; el <y >también aparecen en contextos desequilibradas por lo que el mecanismo de macro no podría extenderse a manejarlos como se maneja paréntesis. (Algunos de los miembros del comité habían abogado por una ficha diferente, por ejemplo (^...^), pero no pudieron convencer a la mayoría de los problemas con el uso <...>).