Virgule dans une macro C / C ++

Disons que nous avons une macro comme celle-ci

#define FOO(type,name) type name

Que nous pourrions utiliser comme

FOO(int, int_var);

Mais pas toujours aussi simplement que ça:

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

Bien sûr, nous pourrions faire:

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

ce qui n'est pas très ergonomique. Les incompatibilités de type Plus doivent être traitées. Une idée comment résoudre ce problème avec une macro?

Parce que les supports d'angle peuvent également représenter (ou se produire dans) les opérateurs de comparaison <, >, <=et >=, l' expansion macro ne peuvent pas ignorer les virgules à l' intérieur crochets comme il le fait entre parenthèses. (C'est également un problème pour les crochets et les accolades, même si ceux-ci se présentent généralement sous forme de paires équilibrées.) Vous pouvez mettre l'argument de macro entre parenthèses:

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

Le problème est alors que le paramètre reste entre parenthèses dans le développement de la macro, ce qui l'empêche d'être lu comme un type dans la plupart des contextes.

Une astuce intéressante pour contourner ce problème est qu'en C ++, vous pouvez extraire un nom de type d'un nom de type entre parenthèses à l'aide d'un type de fonction:

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

Étant donné que la formation des types de fonction ignore les parenthèses supplémentaires, vous pouvez utiliser cette macro avec ou sans parenthèses où le nom du type n'inclut pas de virgule:

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

En C, bien sûr, ce n'est pas nécessaire car les noms de type ne peuvent pas contenir de virgules en dehors des parenthèses. Donc, pour une macro multilingue, vous pouvez écrire:

#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 vous ne pouvez pas utiliser de parenthèses et que vous n'aimez pas la solution SINGLE_ARG de Mike, définissez simplement un COMMA:

#define COMMA ,

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

Cela aide également si vous souhaitez stringifier certains des arguments de macro, comme dans

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

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

Si votre préprocesseur prend en charge les macros variadiques:

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

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

Sinon, c'est un peu plus fastidieux:

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

Définissez simplement FOOcomme

#define UNPACK( ... ) __VA_ARGS__

#define FOO( type, name ) UNPACK type name

Puis invoquez-le toujours avec des parenthèses autour de l'argument type, par exemple

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

Il peut bien sûr être une bonne idée d'illustrer les invocations dans un commentaire sur la définition de la macro.

Il existe au moins deux façons de procéder. Tout d'abord, vous pouvez définir une macro qui prend plusieurs arguments:

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

si vous faites cela, vous constaterez peut-être que vous finissez par définir plus de macros pour gérer plus d'arguments.

Deuxièmement, vous pouvez mettre des parenthèses autour de l'argument:

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

si vous faites cela, vous constaterez peut-être que les parenthèses supplémentaires gâchent la syntaxe du résultat.

Ceci est possible avec P99 :

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

Le code ci-dessus supprime en fait uniquement la dernière virgule de la liste d'arguments. Vérifiez avec clang -E(P99 nécessite un compilateur C99).

La réponse simple est que vous ne pouvez pas. C'est un effet secondaire du choix des <...>arguments de modèle; les <et >apparaissent également dans des contextes déséquilibrés, de sorte que le mécanisme de macro ne peut pas être étendu pour les gérer comme il gère les parenthèses. (Certains membres du comité avaient plaidé pour un jeton différent, par exemple (^...^), mais ils n'ont pas été en mesure de convaincre la majorité des problèmes d'utilisation <...>.)