सबसे सही सुरक्षित प्रिंटफ

कटौती के तहत, आपको एक आकर्षक कहानी मिलेगी कि मैं कैसे बहुत परेशान था, उपयोगकर्ता शाब्दिक (नए मानक से) को बेहतर तरीके से जानने के लिए, लेकिन साथ ही बाद में मैंने उपरोक्त फ़ंक्शन को कार्यान्वित किया, यह भी पता लगाया कि कॉन्स्ट्रेक्स का पता लगाया गया था , और बाद में बहुत ही शाब्दिक रूप से फिर से लिखा । ।

कहानी

2009 तक वापस, आगामी उपयोगकर्ता शाब्दिक के बारे में मिथक इंटरनेट पर दिखाई दिए जो आपको बिल्कुल सब कुछ करने की अनुमति देगा, अर्थात् संकलन समय पर एक स्ट्रिंग पार्स। (वैसे, भूख के लिए धन्यवाद ikalnitsky - मैं सलाह देता हूं कि आप पढ़ने से पहले देखें।) यह टेम्पलेट के साथ उनके विकल्प को संदर्भित करता है। लेकिन यह वहाँ नहीं था। केवल डिजिटल शाब्दिकों के लिए एक पैटर्न के साथ कार्यान्वयन की अनुमति है। और इसका मतलब यह है कि इस तरह से संकलन के दौरान केवल संख्याओं को पार्स किया जा सकता है।

कथानक। एक समाधान के लिए पहले कदम

तब मैं परेशान था। लेकिन Google, मुझे पता चला है कि संकलन के समय टेम्पलेट के बिना स्ट्रिंग को पार्स करना संभव है।

तो, सुरक्षित प्रिंटफ समस्या के समाधान का हिस्सा है।

template< class > struct FormatSupportedType; #define SUPPORTED_TYPE(C, T) \ template<> struct FormatSupportedType< T > { \ constexpr static bool supports(char c) { return c == C; } } SUPPORTED_TYPE('c', char); SUPPORTED_TYPE('d', int); template< std::size_t N > constexpr bool checkFormatHelper(const char (&format)[N], std::size_t current) { return current >= N ? true : format[current] != '%' ? checkFormatHelper( format, current + 1 ) : format[current + 1] == '%' ? checkFormatHelper( format, current + 2 ) : false; } template< std::size_t N, class T, class... Ts > constexpr bool checkFormatHelper(const char (&format)[N], std::size_t current, const T& arg, const Ts & ... args) { return current >= N ? false : format[current] != '%' ? checkFormatHelper( format, current + 1, arg, args... ) : (format[current] == '%' && format[current + 1] == '%') ? checkFormatHelper( format, current + 2, arg, args... ) : FormatSupportedType< T >::supports(format[current + 1]) && checkFormatHelper( format, current + 2, args... ); } template< std::size_t N, class... Ts > constexpr bool checkFormat(const char (&format)[N], const Ts & ... args) { return checkFormatHelper( format, 0, args... ); } int main() { static_assert( checkFormat("%c %d\n", 'v', 1), "Format is incorrect" ); } 

काम का तर्क, मुझे लगता है, बहुत स्पष्ट है: हम संभावित विकल्पों के माध्यम से सॉर्ट करते हैं और, प्रकार और वर्णों के बीच संबंध के आधार पर, परिणाम लौटाते हैं। एक अतिरिक्त वर्ग का उपयोग यह सत्यापित करने के लिए किया जाता है कि समर्थन मौजूद है और प्रतीक से मेल खाता है। नतीजतन, हम संकलन के दौरान प्रारूप की शुद्धता को सत्यापित कर सकते हैं (यदि यह संकलन चरण में जाना जाता है)। अगला, क्लासिक प्रिंटफ का उपयोग करके , परिणाम प्रिंट करें।

 template< std::size_t N, class... ARGS > int safe_printf(const char (&format)[N], ARGS... args) { static_assert( checkFormat(format, args... ), "Format is incorrect" ); return printf( format, args... ); } 

लेकिन मेरी gcc-4.7 इसे नहीं खाना चाहती है! मैंने अचानक फिर से परेशान होने का फैसला किया, लेकिन एक अंतर्दृष्टि आई। आगे बढ़ने के लिए हमें विवशता को समझना होगा । नीचे, मुझे लगता है, लेख का सबसे दिलचस्प हिस्सा।

परिणति। अड़चन समझना

पहले क्या हुआ था? एक संकलन चरण और एक निष्पादन चरण हुआ करता था, यह भी ध्यान दिया जाना चाहिए (हालांकि हर कोई यह जानता है) कि संकलन चरण में टाइपिंग होती है।
अब क्या है? अब बाधा है , जो आपको संकलन चरण में कार्य करने की अनुमति देता है - किसी प्रकार का दंड सामने आता है। हमें स्पष्ट परिभाषाएँ पेश करने की आवश्यकता है: हम न केवल संकलन और निष्पादन पर विचार करेंगे, बल्कि कार्यक्रम के विशिष्ट भागों के संकलन और निष्पादन (हमारे मामले में, कार्य, क्योंकि हम संकलन के दौरान वस्तुओं का उपयोग भी कर सकते हैं) पर विचार करेंगे। उदाहरण के लिए, "फ़ंक्शन f का संकलन", "फ़ंक्शन f का रनटाइम", "संपूर्ण प्रोजेक्ट का संकलन", "प्रोजेक्ट का रनटाइम"।
यही है, अब पूरी परियोजना का संकलन चरण परियोजना की विभिन्न इकाइयों के संकलन और निष्पादन में टूट गया है। आइए एक उदाहरण देखें।

 template< int N > constexpr int f(int n) { return N + n; } int main() { constexpr int i0 = 1; constexpr int i1 = f<i0>(i0); constexpr int i2 = f<i1>(i1); static_assert(i2 == 4, ""); } 

मुझे तुरंत कहना होगा कि यह संकलित करता है लेकिन कुछ भी उपयोगी नहीं है । आइए मुख्य () फ़ंक्शन के संकलन पर करीब से नज़र डालें। सबसे पहले, वैरिएबल I0 को एक मान दिया जाता है, फिर इस वैरिएबल का उपयोग वैरिएबल I1 के मान की गणना करने के लिए किया जाता है, लेकिन इसकी गणना करने के लिए, हमें फ़ंक्शन f <i0> (i0) को निष्पादित करने की आवश्यकता है, लेकिन इसके लिए हमें इसे संकलित करने की आवश्यकता है, और संकलन के लिए इसे मान i0 की आवश्यकता है। इसी तरह f <i1> (i1) के साथ । यही है, हमारे पास निम्नलिखित हैं: मुख्य () फ़ंक्शन को संकलित करने की प्रक्रिया में फ़ंक्शन f <1> (int) का अनुक्रमिक संकलन है, फिर इसका निष्पादन, फिर फ़ंक्शन का संकलन f <2> (int) , और, तदनुसार, इसका निष्पादन।
यह क्या है? एक फ़ंक्शन जिसे कॉन्स्टैक्स के रूप में निर्दिष्ट किया गया है, वह सबसे सामान्य फ़ंक्शन की तरह व्यवहार करता है। आइए फ़ंक्शन को देखें f : N को इसके संकलन के चरण में जाना जाता है, और n - इसके निष्पादन के चरण में।

अलगाव। सुरक्षित Printf को लागू करना

इसलिए यह संकलित नहीं होना चाहता था!

 template< class... ARGS > int safe_printf(const char* format, ARGS... args) { static_assert( checkFormat(format, args... ), "Format is incorrect"); return printf( format, args... ); } 

static_assert को safe_printf फ़ंक्शन के संकलन चरण में अनुमति दी गई है, और प्रारूप केवल इसके निष्पादन के समय ही जाना जाएगा (भले ही संकलन चरण इस समय कुछ और के लिए हो)।
और आप इसके आस-पास कैसे पहुंचे? लेकिन कोई भी तरीका नहीं है, या प्रारूप वर्णों को टेम्पलेट मापदंडों में सम्मिलित करें ताकि वे संकलन चरण में दिखाई दे (और जैसा कि हम याद करते हैं, कस्टम शाब्दिक का उपयोग ऐसा करने के लिए संभव नहीं है) या याद रखें कि जब सब कुछ सुपर कूल, शक्तिशाली और अजेय C + है। + (और यहां तक ​​कि सी ++ 11) असहाय हो जाते हैं, मैक्रोज़ दृश्य में प्रवेश करते हैं!

 #define safe_printf(FORMAT, ...) \ static_assert(checkFormat( FORMAT, __VA_ARGS__ ), "Format is incorrect"); \ printf(FORMAT, __VA_ARGS__) int main() { safe_printf("%c %d\n", 'v', 1); } 

जीत!

Denouement - वास्तव में क्या हुआ या गैर-धुलने वाला किनारा

हमेशा की तरह, पहले हम एक सुखद अंत दिखाते हैं, और फिर यह कैसे निकला। नीचे सुरक्षित प्रिंट का सही कार्यान्वयन है।

 template< char... > struct TemplateLiteral { }; template< char... FORMAT, class... ARGS > int safe_printf_2(TemplateLiteral<FORMAT...>, ARGS... args) { constexpr char format[] = {FORMAT... , '\0'}; static_assert( checkFormat(format, args... ), "Format is incorrect"); return printf( format, args... ); } int main() { safe_printf_2(_("%c %d\n"), 'v', 2); } 

उन कार्यों को एक चर के लिए पारित किया जाता है जिनकी TYPE हमारे लिए दिलचस्प है (और मूल्य नहीं), और उन तर्कों को जिन्हें कटौती करने की आवश्यकता है। यह एक शाब्दिक को टेम्पलेट में बदलने के लिए एक तंत्र को लागू करने के लिए बना हुआ है। आदर्श रूप से, यह शांत होगा यदि, जिस संदर्भ में शाब्दिक मौजूद है, वहाँ अभी भी इस शाब्दिक के लिए सूचकांकों का एक पैकेट होगा (कुछ अलग करना), ताकि यह तब अनपैक किया जा सके, अर्थात्।

 template< std::size_t... INDXs > //... TemplateLiteral<"some literal"[INDXs]...> //... 

लेकिन शाब्दिक की लंबाई और पैक की लंबाई मेल खाना चाहिए, और चूंकि पैक केवल बाहर में प्रवेश किया जा सकता है, तो शाब्दिक को बाहर पारित किया जाना चाहिए, और यदि इसे बाहर पारित किया गया है (लेकिन पैरामीटर के रूप में इसे टेम्पलेट में डालने के लिए अभी भी कोई तंत्र नहीं है), तो इसे सरल रूप में प्रेषित किया जाता है। फ़ंक्शन का तर्क, और इसलिए यह फ़ंक्शन को संकलित करने के चरण में नहीं जाना जाता है जिसमें इसे टेम्पलेट में लपेटा जाना चाहिए, क्योंकि टेम्पलेट प्रकार हैं, और प्रकार संकलन हैं - संक्षेप में, यह असंभव है।
लेकिन मैक्रों के बारे में फिर से याद करें। आप संख्याओं की सूची बनाने के लिए बढ़ावा देने के लिए :: पूर्वप्रक्रमक पूछ सकते हैं। बेशक, उनकी संख्या स्थिर होगी, और इसे केवल प्रीप्रोसेसिंग के चरण में बदलना संभव होगा। यह भी प्रदान करने के लिए आवश्यक है कि संकलन चरण पर शाब्दिक रूप से सूचकांक से तत्व लेना नियंत्रित किया जाता है, इसलिए किसी प्रकार का सुरक्षात्मक तंत्र प्रदान किया जाना चाहिए, और, इसके अलावा, पंक्ति के अंत को साफ करना आवश्यक होगा। और आपको किसी तरह यह जांचने की भी ज़रूरत है कि क्या सभी स्ट्रिंग कैप्चर किए गए हैं, अर्थात्। क्या प्रोग्रामर ने बहुत लंबा शाब्दिक प्रवेश किया? नीचे कोड है।

 template< char... > struct TemplateLiteral { }; //       ; //      ,    template< std::size_t LEN, char CHAR, char... CHARS > struct TemplateLiteralTrim { private: //      //   - ,       template< bool, class, char... > struct Helper; template< char... C1, char... C2 > struct Helper< false, TemplateLiteral<C1...>, C2... > { //  , static_assert(sizeof...(C1) == LEN, "Literal is too large"); typedef TemplateLiteral<C1...> Result; }; template< char... C1, char c1, char c2, char... C2 > struct Helper< true, TemplateLiteral<C1...>, c1, c2, C2... > { typedef typename Helper< (bool)c2, TemplateLiteral<C1..., c1>, c2, C2...>::Result Result; }; public: typedef typename Helper<(bool)CHAR, TemplateLiteral<>, CHAR, CHARS..., '\0' >::Result Result; }; template< class T, std::size_t N > constexpr inline std::size_t sizeof_literal( const T (&)[N] ) { return N; } //      N-   template< std::size_t M > constexpr inline char getNthCharSpec( std::size_t N, const char (&literal)[M] ) { return N < M ? literal[N] : '\0'; } #define GET_Nth_CHAR_FOR_PP(I, N, LIT) ,getNthCharSpec(N, LIT) //      //      , // -      , //    #define TEMPLATE_LITERAL_BASE(MAX, LIT) \ (typename TemplateLiteralTrim< sizeof_literal(LIT) - 1 \ BOOST_PP_REPEAT(MAX, GET_Nth_CHAR_FOR_PP, LIT) >::Result()) // MAX_SYM         #define TEMPLATE_LITERAL(LITERAL) TEMPLATE_LITERAL_BASE(MAX_SYM, LITERAL) int main() { //  safe_printf_2(TEMPLATE_LITERAL("%c %d\n"), 'v', 2); } 

वैसे, मुझे बढ़ावा देने में देखना बहुत दिलचस्प था :: प्रीप्रोसेसर - मैंने कल्पना नहीं की कि वे क्या कर सकते हैं (जैसे अंकगणितीय संचालन)। तो मैक्रों वास्तव में भयानक शक्ति हैं।

असंबंधित फ्रेम। उपयोगकर्ता शाब्दिकों का पुनर्वास

यह दिखाने का समय आ गया है कि मैंने क्यों उन्हें (शाब्दिक) सम्मान देना शुरू किया। एक बार, लगभग दो साल पहले, मुझे ट्यूपल्स के बारे में पता चला। वे मेरे लिए बहुत सुविधाजनक लग रहे थे, लेकिन इन टुपल्स पायथन, नेमर्ल और हास्केल से थे। और जब मैंने C ++ से ट्यूपल्स के बारे में सीखा, तो मैं std :: get <N> (tuple) से बहुत परेशान था - यह बोझिल है, मैंने सोचा था, और तब से मैं एक तत्व प्राप्त करने के लिए एक तंत्र विकसित करना चाहता था, लेकिन वर्ग ब्रैकेट ऑपरेटर के माध्यम से। और यहाँ उपयोगकर्ता शाब्दिक बचाव में आए।

 template< std::size_t > struct Number2Type { }; template< class... Ts > class tupless: public std::tuple<Ts...> { public: template< class... ARGS > tupless(ARGS... args): std::tuple<Ts...>(args...) { } template< std::size_t N > auto operator[](Number2Type<N>) const -> decltype(std::get<N>(std::tuple<Ts...>())) const& { return std::get<N>(*this); } template< std::size_t N > auto operator[](Number2Type<N>) -> decltype(std::get<N>(std::tuple<Ts...>())) & { return std::get<N>(*this); } }; template< std::size_t N > constexpr std::size_t chars_to_int(const char (&array)[N], std::size_t current = 0, std::size_t acc = 0) { return (current >= N || array[current] == 0) ? acc : chars_to_int(array, current + 1, 10 * acc + array[current] - '0'); }; template<char... Cs> constexpr auto operator "" _t() -> Number2Type<chars_to_int((const char[1 + sizeof...(Cs)]){Cs..., '\0'})> { return {}; //      }; int main() { tupless<char, int, float> t('x', 10, 12.45); safe_printf_2(TEMPLATE_LITERAL("%c %d %f"), t[0_t], t[1_t], t[2_t]); } 

क्या दिलचस्प है? ठीक है, सबसे पहले, एक प्रकार को दो बार लिखने के लिए नहीं जो एक शाब्दिक रिटर्न देता है (अर्थात, प्रकार हमारे लिए दिलचस्प है), एक खाली इनिशियलाइज़ेशन सूची का उपयोग किया गया था, और कंपाइलर इसे वांछित प्रकार के ऑब्जेक्ट में डालने और निर्माणकर्ता को वहां डालने का प्रयास करेगा।
यह उपयोगकर्ता शाब्दिक रूप से बहुत दिलचस्प है कि इसका प्रकार सीधे मूल्य पर निर्भर करता है, अर्थात्। उदाहरण के लिए, शाब्दिक प्रकार 2_t नंबर 2 टाइप <2> होगा । इसलिए यहां, मुझे उम्मीद है कि सभी लोग सहज होंगे।
बेशक, इसे मानक पुस्तकालय में जोड़ना अच्छा होगा ...

अद्यतन: मैक्रो के बजाय फ़ंक्शन का उपयोग करना बेहतर है

अद्यतन: विषय को "असामान्य प्रोग्रामिंग" पर ले जाया गया, मुझे लगता है कि यह उसके लिए यहां अधिक आरामदायक होगा।