Dấu phẩy trong macro C / C ++

Giả sử chúng ta có một macro như thế này

#define FOO(type,name) type name

Cái mà chúng tôi có thể sử dụng như

FOO(int, int_var);

Nhưng không phải lúc nào cũng đơn giản như vậy:

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

Tất nhiên chúng tôi có thể làm:

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

mà không phải là rất công thái học. Cộng với sự không tương thích kiểu phải được xử lý. Bất kỳ ý tưởng làm thế nào để giải quyết điều này với macro?

Bởi vì dấu ngoặc nhọn cũng có thể đại diện (hoặc xảy ra trong) các toán tử so sánh <, >, <=và >=, mở rộng vĩ mô không thể bỏ qua dấu phẩy bên trong dấu ngoặc nhọn như nó trong dấu ngoặc đơn. (Đây cũng là vấn đề đối với dấu ngoặc vuông và dấu ngoặc nhọn, mặc dù chúng thường xảy ra dưới dạng các cặp cân bằng.) Bạn có thể đặt đối số macro trong dấu ngoặc đơn:

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

Vấn đề là sau đó, tham số vẫn được đặt trong ngoặc đơn bên trong phần mở rộng macro, điều này ngăn nó được đọc như một kiểu trong hầu hết các ngữ cảnh.

Một mẹo hay để giải quyết vấn đề này là trong C ++, bạn có thể trích xuất một tên kiểu từ tên kiểu trong ngoặc đơn bằng cách sử dụng kiểu hàm:

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

Bởi vì việc tạo kiểu hàm bỏ qua dấu ngoặc đơn, bạn có thể sử dụng macro này có hoặc không có dấu ngoặc đơn trong đó tên kiểu không bao gồm dấu phẩy:

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

Tất nhiên, trong C, điều này không cần thiết vì tên kiểu không thể chứa dấu phẩy bên ngoài dấu ngoặc đơn. Vì vậy, đối với macro đa ngôn ngữ, bạn có thể viết:

#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

Nếu bạn không thể sử dụng dấu ngoặc đơn và bạn không thích giải pháp SINGLE_ARG của Mike, chỉ cần xác định COMMA:

#define COMMA ,

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

Điều này cũng hữu ích nếu bạn muốn xâu chuỗi một số đối số macro, như trong

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

bản in nào std::map<int , int> has typeid name "St3mapIiiSt4lessIiESaISt4pairIKiiEEE".

Nếu bộ tiền xử lý của bạn hỗ trợ macro đa dạng:

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

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

Nếu không, nó sẽ tẻ nhạt hơn một chút:

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

Chỉ cần xác định FOOlà

#define UNPACK( ... ) __VA_ARGS__

#define FOO( type, name ) UNPACK type name

Sau đó, gọi nó luôn với dấu ngoặc đơn xung quanh đối số kiểu, ví dụ:

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

Tất nhiên có thể là một ý tưởng hay để minh họa các lời gọi trong một nhận xét về định nghĩa macro.

Có ít nhất hai cách để làm điều này. Đầu tiên, bạn có thể xác định một macro có nhiều đối số:

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

nếu bạn làm điều đó, bạn có thể thấy rằng bạn sẽ xác định nhiều macro hơn để xử lý nhiều đối số hơn.

Thứ hai, bạn có thể đặt dấu ngoặc đơn xung quanh đối số:

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

nếu bạn làm điều đó, bạn có thể thấy rằng các dấu ngoặc đơn bổ sung làm sai cú pháp của kết quả.

Điều này có thể thực hiện được với P99 :

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

Đoạn mã trên chỉ xóa dấu phẩy cuối cùng trong danh sách đối số một cách hiệu quả. Kiểm tra với clang -E(P99 yêu cầu trình biên dịch C99).

Câu trả lời đơn giản là bạn không thể. Đây là một tác dụng phụ của việc lựa chọn <...>đối số mẫu; các <và >cũng xuất hiện trong bối cảnh không cân bằng nên cơ chế vĩ mô không thể được mở rộng để xử lý chúng như nó xử lý dấu ngoặc đơn. (Chẳng hạn, một số thành viên ủy ban đã tranh luận về một mã thông báo khác (^...^), nhưng họ không thể thuyết phục phần lớn các vấn đề khi sử dụng <...>.)