Koma dalam makro C / C ++

Katakanlah kita memiliki makro seperti ini

#define FOO(type,name) type name

Yang bisa kita gunakan seperti

FOO(int, int_var);

Tetapi tidak selalu sesederhana itu:

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

Tentu saja kami bisa melakukan:

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

yang tidak terlalu ergonomis. Ketidaksesuaian tipe Plus harus ditangani. Ada ide bagaimana mengatasi ini dengan makro?

Karena kurung sudut juga dapat mewakili (atau terjadi pada) operator perbandingan <, >, <=dan >=, ekspansi makro tidak bisa mengabaikan koma di dalam tanda kurung sudut seperti itu tidak dalam tanda kurung. (Ini juga masalah untuk tanda kurung siku dan tanda kurung siku, meskipun itu biasanya terjadi sebagai pasangan seimbang.) Anda bisa mengapit argumen makro dalam tanda kurung:

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

Masalahnya adalah bahwa parameter tetap dalam tanda kurung di dalam perluasan makro, yang mencegahnya dibaca sebagai tipe di sebagian besar konteks.

Trik yang bagus untuk mengatasinya adalah bahwa di C ++, Anda dapat mengekstrak nama jenis dari nama jenis dalam tanda kurung menggunakan jenis fungsi:

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

Karena tipe fungsi pembentuk mengabaikan tanda kurung ekstra, Anda bisa menggunakan makro ini dengan atau tanpa tanda kurung di mana nama tipe tidak menyertakan koma:

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

Di C, tentu saja, ini tidak diperlukan karena nama tipe tidak boleh berisi koma di luar tanda kurung. Jadi, untuk makro lintas bahasa Anda bisa menulis:

#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

Jika Anda tidak dapat menggunakan tanda kurung dan tidak menyukai solusi SINGLE_ARG Mike, cukup tentukan COMMA:

#define COMMA ,

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

Ini juga membantu jika Anda ingin merangkai beberapa argumen makro, seperti dalam

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

yang mencetak std::map<int , int> has typeid name "St3mapIiiSt4lessIiESaISt4pairIKiiEEE".

Jika preprocessor Anda mendukung makro variadic:

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

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

Jika tidak, ini sedikit lebih membosankan:

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

Definisikan FOOsebagai

#define UNPACK( ... ) __VA_ARGS__

#define FOO( type, name ) UNPACK type name

Kemudian panggil selalu dengan tanda kurung di sekitar argumen tipe, misalnya

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

Tentu saja merupakan ide yang bagus untuk memberikan contoh pemanggilan dalam komentar tentang definisi makro.

Setidaknya ada dua cara untuk melakukan ini. Pertama, Anda bisa menentukan makro yang membutuhkan banyak argumen:

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

jika Anda melakukannya, Anda mungkin mendapati bahwa Anda akhirnya menentukan lebih banyak makro untuk menangani lebih banyak argumen.

Kedua, Anda dapat meletakkan tanda kurung di sekitar argumen:

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

jika Anda melakukannya, Anda mungkin menemukan bahwa tanda kurung tambahan mengacaukan sintaks hasil.

Ini dimungkinkan dengan P99 :

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

Kode di atas secara efektif hanya menghapus koma terakhir dalam daftar argumen. Periksa dengan clang -E(P99 membutuhkan kompiler C99).

Jawaban sederhananya adalah Anda tidak bisa. Ini adalah efek samping dari pilihan <...>argumen template; yang <dan >juga muncul dalam konteks yang tidak seimbang sehingga mekanisme makro tidak dapat diperpanjang untuk menangani mereka seperti itu menangani tanda kurung. (Beberapa anggota komite telah memperdebatkan token yang berbeda, katakanlah (^...^), tetapi mereka tidak dapat meyakinkan sebagian besar masalah menggunakan <...>.)