कॉमा ++ मैक्रो

Question

कहते हैं कि हम इस

#define FOO(type,name) type name 

की तरह एक मैक्रो कौन सा हम जैसे

FOO(int, int_var); 

इस्तेमाल कर सकते हैं है लेकिन हमेशा की तरह बस उस के रूप में:

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

बेशक हम कर सकते थे:

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

जो बहुत ergonomic नहीं है। प्लस प्रकार असंगतताओं के साथ निपटा जाना है। मैक्रो के साथ इसे हल करने का कोई विचार है? अन्यथा

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

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

, ताकि उसे कुछ अतिरिक्त थकाऊ है::

Answer 1

क्योंकि कोण कोष्ठक भी प्रतिनिधित्व करते हैं (या में होते हैं) कर सकते हैं तुलना ऑपरेटरों <, >, <= और >=, मैक्रो विस्तार कोष्ठक कोष्ठक के अंदर कोण ब्रैकेट के अंदर अल्पविराम को अनदेखा नहीं कर सकता है। (यह भी वर्ग कोष्ठक और ब्रेसिज़ के लिए एक समस्या है, भले ही उन आम तौर पर संतुलित जोड़े होते हैं।) आप कोष्ठक में मैक्रो तर्क संलग्न कर सकते हैं:

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

समस्या तो है कि पैरामीटर मैक्रो में किसी एक parenthesized रहता है विस्तार, जो इसे अधिकांश संदर्भों में एक प्रकार के रूप में पढ़ने से रोकता है।

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

क्योंकि समारोह प्रकार के गठन अतिरिक्त कोष्ठक पर ध्यान नहीं देता, तो आप इस मैक्रो का उपयोग कर सकते हैं:

एक अच्छा चाल इस समाधान करने के लिए कि सी ++ में, आप एक समारोह प्रकार का उपयोग कर एक parenthesized प्रकार नाम से एक typename निकाल सकते हैं है के साथ या बिना कोष्ठकों जहां प्रकार का नाम एक अल्पविराम शामिल नहीं है:

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

सी में, ज़ाहिर है, इस आवश्यक नहीं है क्योंकि प्रकार के नाम कोष्ठक के बाहर अल्पविराम नहीं कर सकते हैं। तो, एक क्रॉस-भाषा मैक्रो के लिए आप लिख सकते हैं:

#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 

Answer 2

अपने पूर्वप्रक्रमक variadic मैक्रो का समर्थन करता है, तो

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

Answer 3

ऐसा करने के लिए कम से कम दो तरीके हैं। सबसे पहले, आप एक मैक्रो कि कई तर्क लेता है परिभाषित कर सकते हैं:

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

अगर आप आप पा सकते हैं कि है कि आप अधिक तर्क को संभालने के लिए अधिक मैक्रो को परिभाषित खत्म करो।

दूसरे, आप तर्क के आसपास कोष्ठक रख सकते हैं:

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

अगर आप आप पा सकते हैं कि कि अतिरिक्त कोष्ठकों परिणाम की वाक्य रचना अप पेंच है।

Answer 4

सरल उत्तर यह है कि आप नहीं कर सकते हैं। टेम्पलेट तर्कों के लिए यह <...> की पसंद का दुष्प्रभाव है; < और > असंतुलित संदर्भों में भी दिखाई देते हैं ताकि मैक्रो तंत्र को संभालने के लिए विस्तारित नहीं किया जा सके जैसे कि यह ब्रांड्स को संभालता है। (समिति के सदस्यों में से कुछ एक अलग टोकन के लिए तर्क दिया था, कहते हैं कि (^...^), पर वे <...> का उपयोग कर समस्याओं के बहुमत को समझाने के लिए सक्षम नहीं थे।)

Answer 5

यह संभव है P99 साथ:

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

कोड को प्रभावी ढंग से ऊपर तर्क सूची में केवल पिछले अल्पविराम स्ट्रिप्स। clang -E के साथ जांचें (पी 99 को एक सी 99 कंपाइलर की आवश्यकता है)।

Answer 6

आप कोष्ठक का उपयोग नहीं कर सकता है और आप माइक SINGLE_ARG समाधान पसंद नहीं है, सिर्फ एक अल्पविराम को परिभाषित:

#define COMMA , 

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

यह भी मदद करता है अगर आप मैक्रो तर्क के कुछ stringify करना चाहते हैं,

में के रूप में

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

जो std::map<int , int> has typeid name "St3mapIiiSt4lessIiESaISt4pairIKiiEEE" प्रिंट करता है।

Answer 7

बस FOO रूप

#define UNPACK(...) __VA_ARGS__ 

#define FOO(type, name) UNPACK type name 

फिर प्रकार तर्क है, उदा आसपास कोष्ठक के साथ हमेशा यह आह्वान को परिभाषित

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

यह निश्चित रूप से एक अच्छा विचार मैक्रो परिभाषा पर एक टिप्पणी में आमंत्रण का उदाहरण देना हो सकता है।