C / C ++ makrosunda virgül

Böyle bir makromuz olduğunu varsayalım

#define FOO(type,name) type name

Hangi gibi kullanabiliriz

FOO(int, int_var);

Ancak her zaman bu kadar basit değil:

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

Tabii ki yapabiliriz:

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

ki bu çok ergonomik değil. Artı tipi uyumsuzluklarla ilgilenilmelidir. Bunu makro ile nasıl çözeceğiniz hakkında bir fikriniz var mı?

Açılı ayraçlar da ifade etmektedir (ya da meydana) çünkü karşılaştırma operatörleri <, >, <=ve >=parantez içinde olduğu gibi, makro genişleme köşeli parantez içinde virgül göz ardı edilemez. (Bu aynı zamanda köşeli parantezler ve kaşlı ayraçlar için de bir sorundur, bunlar genellikle dengeli çiftler olarak görülse de.) Makro bağımsız değişkenini parantez içine alabilirsiniz:

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

Bu durumda sorun, parametrenin makro genişletme içinde parantez içinde kalması ve bu da çoğu bağlamda bir tür olarak okunmasını engellemesidir.

Bunu geçici olarak çözmenin güzel bir yolu, C ++ 'da, bir işlev türü kullanarak parantezli bir tür adından bir tür adını çıkarabilmenizdir:

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

İşlev türleri oluşturmak fazladan parantezleri yok saydığından, bu makroyu, tür adının virgül içermediği durumlarda parantezli veya parantezsiz kullanabilirsiniz:

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

C de, elbette, bu gerekli değildir çünkü tür adları parantez dışında virgül içeremez. Yani, diller arası bir makro için şunları yazabilirsiniz:

#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

Parantez kullanamıyorsanız ve Mike'ın SINGLE_ARG çözümünü beğenmiyorsanız, bir COMMA tanımlamanız yeterlidir:

#define COMMA ,

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

Bu, aynı zamanda, aşağıdaki gibi bazı makro argümanlarını dizginlemek istiyorsanız da yardımcı olur.

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

hangi baskılar std::map<int , int> has typeid name "St3mapIiiSt4lessIiESaISt4pairIKiiEEE".

Ön işlemciniz değişken makroları destekliyorsa:

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

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

Aksi takdirde, biraz daha sıkıcı olur:

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

FOOOlarak tanımlayın

#define UNPACK( ... ) __VA_ARGS__

#define FOO( type, name ) UNPACK type name

Sonra onu her zaman tür bağımsız değişkeni etrafında parantezle çağırın, örn.

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

Makro tanıma ilişkin bir yorumda çağrıları örneklemek elbette iyi bir fikir olabilir.

Bunu yapmanın en az iki yolu var. İlk olarak, birden çok argüman alan bir makro tanımlayabilirsiniz:

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

Bunu yaparsanız, daha fazla argümanı işlemek için daha fazla makro tanımladığınızı fark edebilirsiniz.

İkinci olarak, bağımsız değişkenin etrafına parantez koyabilirsiniz:

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

bunu yaparsanız, fazladan parantezlerin sonucun sözdizimini bozduğunu görebilirsiniz.

Bu P99 ile mümkündür :

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

Yukarıdaki kod, bağımsız değişken listesindeki yalnızca son virgülü etkili bir şekilde çıkarır. clang -E(P99, bir C99 derleyicisi gerektirir) ile kontrol edin .

Basit cevap, yapamayacağınızdır. Bu, <...>şablon argümanlarının seçiminin bir yan etkisidir ; <ve >makro mekanizması o parantez kolları gibi onları işlemek için uzatılamaz böylece de dengesiz bağlamlarda görünür. (Komite üyelerinden bazıları farklı bir jeton için tartıştılar (^...^), ancak sorunların çoğunu kullanarak ikna edemediler <...>.)