मेटा क्रश सागा: संकलन-समय का खेल

लीड सीनियर सी ++ ओवर-इंजीनियर के लंबे समय से प्रतीक्षित शीर्षक पर जाने की प्रक्रिया में, पिछले साल मैंने खेल को फिर से लिखने का फैसला किया कि मैं आधुनिक C ++ (C ++ 17) के क्विंटेसन का उपयोग करके काम के घंटों (कैंडी क्रश सागा) के दौरान विकसित कर रहा हूं। और इसलिए मेटा क्रश सागा का जन्म हुआ: एक गेम जो संकलन चरण में चलता है । मैं मैट बर्नर के निबलर गेम से बहुत प्रेरित था, जिसने नोकिया 3310 के साथ प्रसिद्ध साँप को फिर से बनाने के लिए टेम्पलेट्स पर शुद्ध मेटाप्रोग्रामिंग का उपयोग किया था।

" यह संकलन के स्तर पर किस तरह का खेल चल रहा है ?", "यह कैसा दिखता है?", "इस परियोजना में आपने C ++ 17 की किस कार्यक्षमता का उपयोग किया?", "आपने क्या सीखा?" - इसी तरह के सवाल आपके दिमाग में आ सकते हैं। उन्हें जवाब देने के लिए, आपको या तो पूरी पोस्ट पढ़नी होगी, या अपने भीतर के आलस्य को खत्म करना होगा और पोस्ट का वीडियो संस्करण देखना होगा - स्टॉकहोम में मीटअप घटना से मेरी रिपोर्ट:


नोट: अपने मानसिक स्वास्थ्य की खातिर और क्योंकि मानव एस्ट्रम को मिटाते हैं , इस लेख में कुछ वैकल्पिक तथ्य दिए गए हैं।

एक खेल जो संकलन के समय चलता है?

मुझे लगता है यह समझने के लिए कि संकलन के चरण में निष्पादित गेम की "अवधारणा" से मेरा क्या मतलब है, आपको इस तरह के खेल के जीवन चक्र की तुलना एक साधारण खेल के जीवन चक्र से करने की आवश्यकता है।

एक नियमित खेल का जीवन चक्र:

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

संकलन प्रक्रिया के दौरान चलने वाले खेल का जीवन चक्र:

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

जैसा कि आप पहले से ही समझ सकते हैं, संकलन प्रक्रिया के दौरान निष्पादित गेम में एक गेम चक्र होता है जिसमें गेम का प्रत्येक फ्रेम एक संकलन चरण होता है । संकलन के प्रत्येक चरण में खेल की एक नई स्थिति की गणना की जाती है, जिसे खिलाड़ी को दिखाया जा सकता है और संकलन के अगले फ्रेम / स्टेज में डाला जा सकता है।

आप इस शानदार आरेख पर उतना ही चिंतन कर सकते हैं जितना कि जब तक आप समझते हैं कि मैंने अभी क्या लिखा है:


इससे पहले कि हम इस तरह के चक्र को लागू करने के विवरण में शामिल हों, मुझे यकीन है कि आप मुझसे एकमात्र सवाल पूछना चाहते हैं ...

"ऐसा करने में परेशान क्यों?"

क्या आप वास्तव में सोचते हैं कि मेरी C ++ मेटाप्रोग्रामिंग आइडियल को बर्बाद करना एक ऐसा मौलिक प्रश्न है? हाँ, जीवन में कुछ भी नहीं!

• पहली और सबसे महत्वपूर्ण बात यह है कि संकलन चरण में निष्पादित गेम में निष्पादन समय की एक अद्भुत गति होगी, क्योंकि गणना चरण में गणना के थोक प्रदर्शन किए जाते हैं। रनटाइम स्पीड ASCII ग्राफिक्स के साथ हमारे एएए गेम की सफलता की कुंजी है!
• आप इस संभावना को कम कर देते हैं कि कुछ क्रस्टेशियन आपकी रिपॉजिटरी में दिखाई देंगे और आपसे खेल को रस्ट में फिर से लिखने के लिए कहेंगे। जैसे ही आप उसे समझाते हैं कि उसका अवैध भाषण समाप्त हो जाएगा, एक अमान्य सूचक संकलन समय पर मौजूद नहीं हो सकता। हास्केल के आत्मविश्वास से भरे प्रोग्रामर भी आपके कोड में सुरक्षा की पुष्टि कर सकते हैं।
• आप जावास्क्रिप्ट हिपस्टर साम्राज्य का सम्मान जीतेंगे, जिसमें एक मजबूत NIH सिंड्रोम के साथ किसी भी पुन: डिज़ाइन किए गए ढांचे पर शासन किया जा सकता है, बशर्ते कि यह एक शांत नाम के साथ आता है।
• मेरा एक दोस्त कहता था कि पर्ल कोड की किसी भी लाइन को वास्तव में एक बहुत मजबूत पासवर्ड के रूप में इस्तेमाल किया जा सकता है। मुझे यकीन है कि उसने कभी भी C ++ कंपाइल टाइम से पासवर्ड जेनरेट करने की कोशिश नहीं की।

खैर? क्या आप मेरे उत्तरों से संतुष्ट हैं? तब शायद आपका सवाल यह होना चाहिए: "आप इसे कैसे प्रबंधित करते हैं?"

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

मेटा क्रश सागा गेम रिव्यू

मैच -3 खेल:

मेटा क्रश सागा बेजलवेड और कैंडी क्रश सागा के समान एक टाइल जॉइनिंग गेम है । खेल के नियमों का मूल बिंदुओं को प्राप्त करने के लिए एक ही पैटर्न के साथ तीन टाइलों को जोड़ना है। यहाँ खेल की स्थिति पर एक त्वरित नज़र है जिसे मैंने "डंप" किया (ASCII में डंपिंग करना बहुत आसान है) प्राप्त करना आसान है:

  आर ”(
     मेटा क्रश सागा      
 ------------------------  
 |  | 
 |  RBGBBYGR | 
 |  | 
 |  | 
 |  YYGRBGBR | 
 |  | 
 |  | 
 |  RBYRGRYG | 
 |  | 
 |  | 
 |  RYBY (R) YGY | 
 |  | 
 |  | 
 |  BGYRYGGR | 
 |  | 
 |  | 
 |  RYBGYBBG | 
 |  | 
 ------------------------  
 > स्कोर: 9009
 > चाल: २:
 ) " 

इस मैच -3 गेम का गेमप्ले अपने आप में विशेष रूप से दिलचस्प नहीं है, लेकिन उस वास्तुकला के बारे में क्या है जिस पर यह सब काम करता है? इसे समझने के लिए, मैं कोड के संदर्भ में इस संकलन-समय के खेल के जीवन चक्र के हर हिस्से को समझाने की कोशिश करूंगा।

खेल राज्य इंजेक्शन:

यदि आप एक भावुक C ++ प्रेमी या पेडेंट हैं, तो आपने देखा होगा कि पिछला गेम स्टेट डंप निम्न पैटर्न से शुरू होता है: "R" ( ! वास्तव में, यह एक कच्चा C ++ 11 स्ट्रिंग शाब्दिक है , जिसका अर्थ है कि मुझे विशेष वर्णों से बचने की आवश्यकता नहीं है, उदाहरण के लिए, अनुवाद स्ट्रिंग्स : कच्ची स्ट्रिंग शाब्दिक फ़ाइल को current_state.txt नामक फ़ाइल में संग्रहीत किया जाता है।

हम खेल की वर्तमान स्थिति को संकलन स्थिति में कैसे इंजेक्ट करते हैं? चलो बस इसे लूप इनपुट में जोड़ दें!

// loop_inputs.hpp constexpr KeyboardInput keyboard_input = KeyboardInput::KEYBOARD_INPUT; //       constexpr auto get_game_state_string = []() constexpr { auto game_state_string = constexpr_string( //       #include "current_state.txt" ); return game_state_string; }; 

चाहे वह एक .txt फ़ाइल या एक .h फ़ाइल हो, C प्रीप्रोसेसर से निर्देश शामिल उसी तरह से काम करेगा: यह फ़ाइल की सामग्री को उसके स्थान पर कॉपी करता है। यहाँ मैं खेल राज्य के कच्चे स्ट्रिंग शाब्दिक को ascii में एक चर में game_state_string नामक कॉपी करता हूं ।

ध्यान दें कि loop_inputs.hpp हेडर फ़ाइल भी कीबोर्ड इनपुट को मौजूदा फ्रेम / संकलन चरण तक विस्तारित करती है। खेल की स्थिति के विपरीत, कीबोर्ड की स्थिति काफी छोटी है और इसे आसानी से एक प्रीप्रोसेसर की परिभाषा के रूप में प्राप्त किया जा सकता है।

संकलित समय पर एक नए राज्य की गणना:

अब जब हमने पर्याप्त डेटा एकत्र कर लिया है, तो हम नए राज्य की गणना कर सकते हैं। अंत में, हम उस बिंदु पर पहुँच गए हैं जहाँ हमें main.cpp फ़ाइल लिखने की आवश्यकता है:

 // main.cpp #include "loop_inputs.hpp" //   ,   . // :    . constexpr auto current_state = parse_game_state(get_game_state_string); //      . constexpr auto new_state = game_engine(current_state) //    , .update(keyboard_input); //  ,    . constexpr auto array = print_game_state(new_state); //      std::array<char>. // :    . //  :   . for (const char& c : array) { std::cout << c; } 

अजीब बात है, लेकिन यह सी ++ कोड इतना भ्रामक नहीं लगता है कि यह क्या करता है। अधिकांश कोड को संकलन चरण में निष्पादित किया जाता है, हालांकि, यह पारंपरिक ओओपी और प्रक्रियात्मक प्रोग्रामिंग प्रतिमानों का अनुसरण करता है। केवल अंतिम पंक्ति - प्रतिपादन - संकलन समय पर पूरी तरह से गणना करने के लिए एक बाधा है। जैसा कि हम नीचे देखेंगे, सही जगहों पर थोड़ा सा कब्ज़ा फेंकने पर, हम C ++ 17 में काफी सुरुचिपूर्ण मेटाप्रोग्रामिंग प्राप्त कर सकते हैं। मैं स्वतंत्रता को आनंदमय पाता हूं जो C ++ हमें देता है जब रनटाइम और संकलन में मिश्रित निष्पादन की बात आती है।

आप यह भी देखेंगे कि यह कोड केवल एक फ्रेम निष्पादित करता है, कोई गेम लूप नहीं है । आइए इस मुद्दे को हल करें!

हम सब कुछ एक साथ गोंद करते हैं:

यदि आप सी ++ के साथ मेरी चाल को घृणा करते हैं, तो मुझे आशा है कि आप मेरे बैश कौशल को देखने में कोई आपत्ति नहीं करेंगे। वास्तव में, मेरा गेम लूप बैश स्क्रिप्ट से अधिक कुछ नहीं है जो लगातार संकलन करता है।

 #  !  ,    !!! while; do : #      G++ g++ -o renderer main.cpp -DKEYBOARD_INPUT="$keypressed" keypressed=get_key_pressed() #  . clear #   current_state=$(./renderer) echo $current_state #    #     current_state.txt file       . echo "R\"(" > current_state.txt echo $current_state >> current_state.txt echo ")\"" >> current_state.txt done 

वास्तव में, मुझे कंसोल से कीबोर्ड इनपुट प्राप्त करने में थोड़ी परेशानी हो रही थी। प्रारंभ में, मैं संकलन के साथ समानांतर में प्राप्त करना चाहता था। कई परीक्षण और त्रुटि के बाद, मैं बैश से read कमांड के साथ कम या ज्यादा काम करने में कामयाब रहा। मैं एक विवाद में जादूगर बैश से लड़ने की हिम्मत नहीं करता - यह भाषा बहुत भयावह है!

इसलिए, मुझे यह स्वीकार करना होगा कि खेल चक्र का प्रबंधन करने के लिए मुझे दूसरी भाषा का सहारा लेना होगा। हालाँकि तकनीकी रूप से कुछ भी मुझे C ++ में कोड के इस भाग को लिखने से नहीं रोकता था। इसके अलावा, यह इस तथ्य को नकारता नहीं है कि मेरे खेल का 90% तर्क जी ++ संकलन टीम के अंदर निष्पादित होता है , जो कि बहुत आश्चर्यजनक है!

अपनी आंखों को आराम देने के लिए थोड़ा गेमप्ले:

अब जब आपने खेल की वास्तुकला को समझाने की पीड़ा का अनुभव किया है, तो आंखों को पकड़ने वाले चित्रों का समय आ गया है:


यह पिक्सलेटेड gif एक रिकॉर्ड है कि मैं मेटा क्रश सागा कैसे खेलता हूं। जैसा कि आप देख सकते हैं, वास्तविक समय में खेल खेलने के लिए खेल आसानी से चलता है। जाहिर है, वह इतनी आकर्षक नहीं है कि मैं उसकी ट्विच को स्ट्रीम कर सकूं और नई पेवडीपी बन सकूं, लेकिन वह काम करती है!

एक .txt फ़ाइल में किसी गेम की स्थिति को संग्रहीत करने के मज़ेदार पहलुओं में से एक है, चरम मामलों को बहुत आसानी से धोखा देना या परीक्षण करना।

अब जब मैंने आपको संक्षेप में वास्तुकला के लिए पेश किया है, तो हम इस परियोजना में प्रयुक्त C ++ 17 कार्यक्षमता में तल्लीन करेंगे। मैं गेम लॉजिक पर विस्तार से विचार नहीं करूंगा, क्योंकि यह विशेष रूप से मैच -3 को संदर्भित करता है, लेकिन इसके बजाय मैं सी ++ के पहलुओं के बारे में बात करूंगा जो अन्य परियोजनाओं में लागू हो सकते हैं।

C ++ 17 के बारे में मेरा ट्यूटोरियल:

C ++ 14 के विपरीत, जिसमें मुख्य रूप से मामूली सुधार शामिल थे, नया C ++ 17 मानक हमें बहुत कुछ प्रदान कर सकता है। ऐसी उम्मीदें थीं कि आखिरकार लंबे समय से प्रतीक्षित विशेषताएं (मॉड्यूल, कॉरटुइन, अवधारणाएं ...) आखिरकार दिखाई देंगी, लेकिन सामान्य रूप से ... वे दिखाई नहीं दीं; इसने हम में से कई लोगों को परेशान किया। लेकिन शोक को दूर करने के बाद, हमें कई छोटे अप्रत्याशित खजाने मिले जो अभी भी मानक में नहीं थे।

मैं यह कहने की हिम्मत करता हूं कि जो बच्चे मेटाप्रोग्रामिंग से प्यार करते हैं वे इस साल बहुत खराब हो जाते हैं! भाषा में अलग-अलग मामूली बदलाव और परिवर्धन अब आपको कोड लिखने की अनुमति देता है जो बहुत कम समय में और बाद के समय में काम करता है।

सभी क्षेत्रों में बाधा:

जैसा कि बेन डीन और जेसन टर्नर ने सी ++ 14 पर अपनी रिपोर्ट में भविष्यवाणी की थी, सी ++ आपको सर्वशक्तिमान कीवर्ड बाधा के साथ संकलन समय पर मूल्यों के संकलन में तेजी से सुधार करने की अनुमति देता है। इस कीवर्ड को सही स्थानों पर स्थित करके, आप संकलक को बता सकते हैं कि अभिव्यक्ति स्थिर है और संकलन समय पर सीधे मूल्यांकन किया जा सकता है । C ++ 11 में, हम पहले से ही यह कोड लिख सकते हैं:

 constexpr int factorial(int n) //    constexpr       . { return n <= 1? 1 : (n * factorial(n - 1)); } int i = factorial(5); //  constexpr-. //      : // int i = 120; 

हालाँकि, कॉन्स्टैक्स कीवर्ड बहुत शक्तिशाली है, लेकिन इसमें कुछ उपयोग प्रतिबंध हैं, जिससे इस तरह से एक्सप्रेसिव कोड लिखना मुश्किल हो जाता है।

C ++ 14 ने कॉन्स्टैक्स के लिए आवश्यकताओं को बहुत कम कर दिया है और उपयोग करने के लिए बहुत अधिक प्राकृतिक हो गया है। हमारे पिछले फैक्टरियल फ़ंक्शन को निम्नानुसार फिर से लिखा जा सकता है:

 constexpr int factorial(int n) { if (n <= 1) { return 1; } return n * factorial(n - 1); } 

C ++ 14 ने इस नियम से छुटकारा पा लिया कि एक कॉन्स्ट्रेक्स फ़ंक्शन में केवल एक रिटर्न स्टेटमेंट शामिल होना चाहिए, जिसने हमें टर्नरी ऑपरेटर को मुख्य बिल्डिंग ब्लॉक के रूप में उपयोग करने के लिए मजबूर किया। अब C ++ 17 और भी अधिक कॉन्सेप्ट कीवर्ड एप्लिकेशन लाता है जिसे हम एक्सप्लोर कर सकते हैं!

संकलन के समय शाखाएँ:

क्या आप कभी ऐसी स्थिति में आए हैं जहाँ आपको उस टेम्पलेट पैरामीटर के आधार पर अलग व्यवहार प्राप्त करने की आवश्यकता होती है जिसे आप जोड़ तोड़ कर रहे हैं? मान लें कि हमें एक .serialize() फ़ंक्शन serialize की आवश्यकता है, जो कि .serialize() कॉल करेगा यदि ऑब्जेक्ट इसे प्रदान करता है, अन्यथा यह इसके लिए कॉल to_string सहारा to_string । जैसा कि SFINAE के बारे में इस पोस्ट में अधिक विस्तार से बताया गया है, सबसे अधिक संभावना है कि आपको इस तरह के एक विदेशी कोड लिखना होगा:

 template <class T> std::enable_if_t<has_serialize_v<T>, std::string> serialize(const T& obj) { return obj.serialize(); } template <class T> std::enable_if_t<!has_serialize_v<T>, std::string> serialize(const T& obj) { return std::to_string(obj); } 

केवल एक सपने में आप SFINAE चाल से C ++ 14 तक इस बदसूरत कोड को ऐसे शानदार कोड में फिर से लिख सकते हैं:

 // has_serialize -  constexpr-,  serialize  . // .    SFINAE,  ,    . template <class T> constexpr bool has_serialize(const T& /*t*/); template <class T> std::string serialize(const T& obj) { //  ,  constexpr    . if (has_serialize(obj)) { return obj.serialize(); } else { return std::to_string(obj); } } 

दुर्भाग्य से, जब आप जाग गए और वास्तविक C ++ 14 कोड लिखना शुरू कर दिया, तो आपके संकलक ने serialize(42); कॉलिंग के बारे में एक अप्रिय संदेश उगल दिया serialize(42); । यह समझाया कि एक प्रकार के int का एक सदस्य फ़ंक्शन serialize() । कोई फर्क नहीं पड़ता कि यह आपको कैसे प्रभावित करता है, संकलक सही है! इस कोड के साथ, वह हमेशा दोनों शाखाओं को संकलित करने की कोशिश करेगा - return obj.serialize(); और
return std::to_string(obj); । int शाखा return obj.serialize(); यह अच्छी तरह से कुछ मृत कोड हो सकता है, क्योंकि has_serialize(obj) हमेशा false वापस आ जाएगा, लेकिन कंपाइलर को अभी भी इसे संकलित करना होगा।

जैसा कि आपने शायद अनुमान लगाया था, C ++ 17 हमें इस तरह की अप्रिय स्थिति से बचाता है, क्योंकि यह संकलन समय पर "बल" शाखाओं में बँटाने और अप्रयुक्त निर्माणों को त्यागने के बाद कॉन्स्टैक्स को जोड़ना संभव बनाता है :

 // has_serialize... // ... template <class T> std::string serialize(const T& obj) if constexpr (has_serialize(obj)) { //     constexpr   'if'. return obj.serialize(); //    ,    ,  obj  int. } else { return std::to_string(obj);branch } } 

जाहिर है, यह SFINAE चाल पर भारी सुधार है जिसे हमें पहले लागू करना था। उसके बाद, हमें बेन और जेसन के रूप में एक ही लत लगनी शुरू हुई - हमने हर जगह और हमेशा कॉन्स्टैक्स का उपयोग करना शुरू कर दिया। काश, एक और जगह है जहाँ कॉन्स्ट्रेक्स कीवर्ड फिट होगा, लेकिन अभी तक उपयोग नहीं किया गया है: कॉन्स्टैक्स पैरामीटर ।

कांस्ट्रेक्स पैरामीटर:

यदि आप सावधान हैं, तो आप पिछले कोड उदाहरण में एक अजीब पैटर्न देख सकते हैं। मैं लूप इनपुट के बारे में बात कर रहा हूं:

 // loop_inputs.hpp constexpr auto get_game_state_string = []() constexpr // ? { auto game_state_string = constexpr_string( //       #include "current_state.txt" ); return game_state_string; }; 

वैरिएबल game_state_string को कॉन्स्टैक्स लैम्ब्डा में क्यों समझाया जाता है? वह उसे एक वैश्विक परिवर्तनशील बाधा क्यों नहीं बनाता है ?

मैं इस चर और इसकी सामग्री को कुछ कार्यों में गहराई से पारित करना चाहता था। उदाहरण के लिए, आपको इसे मेरे parse_board पर भेजना होगा और कुछ स्थिर भावों में इसका उपयोग करना होगा:

 constexpr int parse_board_size(const char* game_state_string); constexpr auto parse_board(const char* game_state_string) { std::array<GemType, parse_board_size(game_state_string)> board{}; // ^ 'game_state_string' -   - // ... } parse_board(“...something...”); 

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

• एक constexpr फ़ंक्शन के तर्क constexpr नहीं हैं!
• और हम उनके सामने बाधा नहीं जोड़ सकते हैं!

यह सब इस तथ्य पर उबलता है कि कॉन्स्टैक्सप्रूट कार्य क्रम और संकलन समय दोनों में लागू होना चाहिए। कॉन्स्टैक्स मापदंडों के अस्तित्व को मानते हुए, यह उन्हें रन टाइम पर उपयोग करने की अनुमति नहीं देगा।


सौभाग्य से, इस समस्या को समतल करने का एक तरीका है। मान को किसी फ़ंक्शन के नियमित पैरामीटर के रूप में स्वीकार करने के बजाय, हम इस मान को एक प्रकार में एन्क्रिप्ट कर सकते हैं और इस प्रकार को टेम्पलेट पैरामीटर की तरह पास कर सकते हैं:

 template <class GameStringType> constexpr auto parse_board(GameStringType&&) { std::array<CellType, parse_board_size(GameStringType::value())> board{}; // ... } struct GameString { static constexpr auto value() { return "...something..."; } }; parse_board(GameString{}); 

इस कोड उदाहरण में, मैं एक GameString संरचनात्मक प्रकार का निर्माण कर रहा हूं जिसमें एक स्थिर सदस्य फ़ंक्शन कॉन्स्टैक्स मूल्य () है जो स्ट्रिंग शाब्दिक रिटर्न देता है जिसे मैं पार्स_बोर्ड पर पास करना चाहता हूं । Parse_board में, मैं इस प्रकार को GameStringType टेम्पलेट पैरामीटर के माध्यम से प्राप्त करता हूं , टेम्पलेट तर्कों को निकालने के लिए नियमों का उपयोग करता है। एक GameStringType होने के कारण, इस तथ्य के कारण कि मान () संकुचित है, मैं स्थैतिक सदस्य फ़ंक्शन मान () को सही समय पर एक स्ट्रिंग शाब्दिक रूप से उन स्थानों पर भी कॉल कर सकता हूं जहां लगातार अभिव्यक्ति की आवश्यकता होती है।

हम किसी भी तरह से कॉन्स्ट्रेक्स का उपयोग करके पार्स_बोर्ड को पास करने के लिए शाब्दिक रूप से संक्षिप्त करने में कामयाब रहे। हालाँकि, एक नए प्रकार को परिभाषित करने की आवश्यकता के लिए हर बार आपको एक नया पार्स_बोर्ड शाब्दिक भेजने की आवश्यकता होती है: "... कुछ 1 ...", "... कुछ 2 ..."। C ++ 11 में इस समस्या को हल करने के लिए, आप अनाम यूनियन और लैम्ब्डा का उपयोग करके कुछ बदसूरत मैक्रो और अप्रत्यक्ष रूप से संबोधित कर सकते हैं। माइकल पार्क ने अपने एक पोस्ट में इस विषय को अच्छी तरह समझाया।

C ++ 17 में, स्थिति और भी बेहतर है। यदि हम अपने स्ट्रिंग शाब्दिक पारित करने के लिए आवश्यकताओं को सूचीबद्ध करते हैं, तो हमें निम्नलिखित मिलते हैं:

• कार्य उत्पन्न हुआ
• वह विवश है
• एक अद्वितीय या अनाम नाम के साथ

इन आवश्यकताओं को आपको संकेत देना चाहिए। हमें क्या जरूरत है कॉन्स्टैक्सप्र लैंबडा की ! और सी ++ 17 में, उन्होंने पूरी तरह से स्वाभाविक रूप से लैम्ब्डा कार्यों के लिए कॉन्स्ट्रेक्स कीवर्ड का उपयोग करने की क्षमता को जोड़ा। हम अपने नमूना कोड को फिर से लिख सकते हैं:

 template <class LambdaType> constexpr auto parse_board(LambdaType&& get_game_state_string) { std::array<CellType, parse_board_size(get_game_state_string())> board{}; // ^      constexpr-. } parse_board([]() constexpr -> { return “...something...”; }); // ^    constexpr. 

मेरा विश्वास करो, यह पहले से ही मैक्रो का उपयोग करके सी ++ 11 में पिछली हैकिंग की तुलना में बहुत अधिक सुविधाजनक लगता है। मैंने Bjorn Fahler के लिए इस भयानक चाल की खोज की, मैं C ++ मिट्टैप समूह का एक सदस्य हूं जिसमें मैं भाग लेता हूं। इस ट्रिक के बारे में उनके ब्लॉग में और पढ़ें। यह भी विचार करने योग्य है कि वास्तव में इस मामले में कॉन्स्ट्रेक्स कीवर्ड वैकल्पिक है: कॉम्पेक्स बनने की क्षमता वाले सभी लैंबड उन्हें डिफ़ॉल्ट रूप से होंगे। स्पष्ट रूप से constexpr को जोड़ना एक हस्ताक्षर है जो हमारी समस्या निवारण को सरल करता है।

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

constexpr_string और constexpr_string_view:

स्ट्रिंग्स के साथ काम करते समय, आपको उन्हें सी शैली में संसाधित नहीं करना चाहिए। आपको इन सभी कष्टप्रद एल्गोरिदम को भूलना होगा जो कच्चे पुनरावृत्तियों का प्रदर्शन करते हैं और शून्य पूरा होने की जांच करते हैं! C ++ द्वारा प्रस्तावित विकल्प सर्वव्यापी std :: string और STL एल्गोरिदम है । दुर्भाग्य से, std :: string को अपनी सामग्री को संग्रहीत करने के लिए (यहां तक ​​कि छोटे स्ट्रिंग ऑप्टिमाइज़ेशन के साथ) मेमोरी आवंटन की आवश्यकता हो सकती है। एक या दो मानकों पर वापस, हम कॉन्स्ट्रेक न्यू / डिलीट का उपयोग कर सकते हैं या हम एसटीआर स्ट्रिंग के लिए कॉन्स्टैक्सप्रो एलोकेटर पास कर सकते हैं, लेकिन अब हमें एक और समाधान खोजने की जरूरत है।

मेरा दृष्टिकोण एक निश्चित क्षमता के साथ एक constexpr_string वर्ग लिखना था। यह क्षमता मान टेम्पलेट के लिए एक पैरामीटर के रूप में पारित की जाती है। यहाँ मेरी कक्षा का संक्षिप्त विवरण दिया गया है:

 template <std::size_t N> // N -    . class constexpr_string { private: std::array<char, N> data_; //  N char   -. std::size_t size_; //   . public: constexpr constexpr_string(const char(&a)[N]): data_{}, size_(N -1) { //   data_ } // ... constexpr iterator begin() { return data_; } //    . constexpr iterator end() { return data_ + size_; } //     . // ... }; 

मेरा constexpr_string वर्ग एसटीडी की नकल करने का प्रयास करता है :: स्ट्रिंग इंटरफ़ेस जितना संभव हो सके (संचालन के लिए) मेरी आवश्यकता है: हम शुरुआत और अंत के पुनरावृत्तियों से अनुरोध कर सकते हैं, आकार (आकार) प्राप्त कर सकते हैं, डेटा (डेटा) का उपयोग कर सकते हैं, उन्हें हटा सकते हैं (मिटा सकते हैं)। सबस्ट्रेटिंग इत्यादि का उपयोग करते हुए। इससे कोड का एक भाग std :: string से constexpr_string में परिवर्तित करना बहुत आसान हो जाता है । आपको आश्चर्य हो सकता है कि तब क्या होता है जब हमें ऑपरेशन का उपयोग करने की आवश्यकता होती है जो आमतौर पर std :: string में हाइलाइटिंग की आवश्यकता होती है। ऐसे मामलों में, मुझे उन्हें उन अपरिवर्तनीय परिचालनों में बदलने के लिए मजबूर किया गया जो constexpr_string का एक नया उदाहरण बनाते हैं ।

आइए नजर डालते हैं अपेंडिक्स ऑपरेशन पर:

 template <std::size_t N> // N -    . class constexpr_string { // ... template <std::size_t M> // M -    . constexpr auto append(const constexpr_string<M>& other) { constexpr_string<N + M> output(*this, size() + other.size()); // ^    . ^     output. for (std::size_t i = 0; i < other.size(); ++i) { output[size() + i] = other[i]; ^     output. } return output; } // ... }; 

आपको यह मानने के लिए फील्ड्स पुरस्कार की आवश्यकता नहीं है कि यदि हमारे पास आकार N की एक स्ट्रिंग और आकार M की एक स्ट्रिंग है, तो आकार N + M की एक स्ट्रिंग उनके संघनन को संग्रहीत करने के लिए पर्याप्त होगी। हम "संकलन-समय भंडार" का हिस्सा बर्बाद कर सकते हैं, क्योंकि दोनों लाइनें पूरी क्षमता का उपयोग नहीं कर सकती हैं, लेकिन यह सुविधा के लिए एक छोटी सी कीमत है। जाहिर है, मैंने std :: string_view का डुप्लिकेट भी लिखा है, जिसे constexpr_string_view कहा जाता है।

इन दो वर्गों के साथ, मैं अपने खेल राज्य को पार्स करने के लिए सुरुचिपूर्ण कोड लिखने के लिए तैयार था। कुछ इस तरह से सोचें:

 constexpr auto game_state = constexpr_string(“...something...”); //          : constexpr auto blue_gem = find_if(game_state.begin(), game_state.end(), [](char c) constexpr -> { return c == 'B'; } ); 

खेल के मैदान पर गहनों के चारों ओर घूमना बहुत आसान था - वैसे, क्या आपने इस कोड उदाहरण में C ++ 17 की एक और कीमती विशेषता देखी है ?

हाँ! इसका निर्माण करते समय मुझे constexpr_string की क्षमता को स्पष्ट रूप से निर्दिष्ट नहीं करना था। पहले, क्लास टेम्पलेट का उपयोग करते समय, हमें इसके तर्कों को स्पष्ट रूप से इंगित करना था। इन वेदनाओं से बचने के लिए, हम make_xxx फ़ंक्शंस बनाते हैं क्योंकि फ़ंक्शन टेम्प्लेट के मापदंडों का पता लगाया जा सकता है। देखें कि कैसे ट्रैकिंग क्लास के तर्कों ने हमारे जीवन को बेहतर के लिए बदल दिया है:

 template <int N> struct constexpr_string { constexpr_string(const char(&a)[N]) {} // .. }; // ****  C++17 **** template <int N> constexpr_string<N> make_constexpr_string(const char(&a)[N]) { //      N ^   return constexpr_string<N>(a); // ^    . } auto test2 = make_constexpr_string("blablabla"); // ^      . constexpr_string<7> test("blabla"); // ^      ,    . // ****  C++17 **** constexpr_string test("blabla"); // ^    ,  . 

कुछ कठिन परिस्थितियों में, आपको सही ढंग से तर्कों की गणना करने के लिए संकलक की मदद करने की आवश्यकता होगी। यदि आप इस तरह की समस्या का सामना करते हैं, तो उपयोगकर्ता-परिभाषित तर्क गणना के लिए मैनुअल का अध्ययन करें।

एसटीएल से मुफ्त भोजन:

खैर, हम हमेशा अपने दम पर सब कुछ फिर से लिख सकते हैं। लेकिन शायद समिति के सदस्यों ने उदारता से हमारे लिए मानक पुस्तकालय में कुछ तैयार किया है?

नए सहायक प्रकार:

C ++ 17 में , std :: variant और std :: वैकल्पिक को मानक शब्दकोश प्रकारों में जोड़ा जाता है, जो कॉन्स्टैक्स पर आधारित है। पहला बहुत दिलचस्प है क्योंकि यह हमें टाइप-सेफ एसोसिएशनों को व्यक्त करने की अनुमति देता है, लेकिन जीसीसी 7.2 के साथ libstdc ++ लाइब्रेरी में कार्यान्वयन में निरंतर अभिव्यक्ति का उपयोग करते समय समस्याएं होती हैं। इसलिए, मैंने अपने कोड में std :: variant जोड़ने का विचार त्याग दिया और केवल std :: वैकल्पिक का उपयोग किया।

टाइप टी के साथ , प्रकार एसटीडी :: वैकल्पिक हमें एक नया प्रकार एसटीडी :: वैकल्पिक <टी> बनाने की अनुमति देता है , जिसमें टाइप टी का मूल्य या कुछ भी नहीं हो सकता है। यह काफी सार्थक प्रकारों के समान है जो C # में अपरिभाषित मूल्य की अनुमति देता है । आइए find_in_board फ़ंक्शन को देखें , जो किसी फ़ील्ड पर पहले तत्व की स्थिति लौटाता है जो पुष्टि करता है कि सही है। मैदान पर ऐसा कोई तत्व नहीं हो सकता है। इस स्थिति को संभालने के लिए, स्थिति प्रकार वैकल्पिक होना चाहिए:

 template <class Predicate> constexpr std::optional<std::pair<int, int>> find_in_board(GameBoard&& g, Predicate&& p) { for (auto item : g.items()) { if (p(item)) { return {item.x, item.y}; } //   ,     . } return std::nullopt; //      . } auto item = find_in_board(g, [](const auto& item) { return true; }); if (item) { // ,   optional. do_something(*item); //    optional, ""   *. /* ... */ } 

पहले, हमें या तो पॉइंटर्स के शब्दार्थ का सहारा लेना था , या सीधे स्थिति के प्रकार में "खाली स्थिति" जोड़ना था, या बूलियन वापस करना और आउटपुट पैरामीटर लेना था । बेशक, यह बहुत अजीब था!

कुछ पहले से मौजूद प्रकारों को भी कॉन्स्ट्रेक्प्र सपोर्ट मिला : टपल और पेयर । मैं उनके उपयोग के बारे में विस्तार से नहीं बताऊंगा, क्योंकि उनके बारे में पहले ही बहुत कुछ लिखा जा चुका है, लेकिन मैं अपनी एक निराशा साझा करूंगा। समिति ने एक ट्यूपल या युग्म में निहित मूल्यों को निकालने के लिए मानक चीनी को मानक में जोड़ा । इस नए प्रकार की घोषणा को संरचित बंधन कहा जाता है, कोष्ठक का उपयोग करता है, जिसमें यह निर्दिष्ट करने के लिए कि विभाजित टपल या जोड़ी को किस चर पर रखा जाए :

 std::pair<int, int> foo() { return {42, 1337}; } auto [x, y] = foo(); // x = 42, y = 1337. 

बहुत होशियार! लेकिन यह अफ़सोस की बात है कि समिति के सदस्य [नहीं कर सकते थे, नहीं चाहते थे, समय नहीं मिला, भूल गए] उन्हें विवश करने के लिए अनुकूल बना दिया । मैं कुछ इस तरह की उम्मीद करूंगा:

 constexpr auto [x, y] = foo(); // OR auto [x, y] constexpr = foo(); 

अब हमारे पास जटिल कंटेनर और सहायक प्रकार हैं, लेकिन हम उन्हें आसानी से कैसे जोड़ सकते हैं?

एल्गोरिदम:

कॉन्स्ट्रेक्स के प्रसंस्करण के लिए एक कंटेनर का उन्नयन एक बहुत नीरस काम है। इसकी तुलना में, गैर- संशोधित एल्गोरिदम में कॉन्स्टैक्स को पोर्ट करना काफी सरल लगता है। लेकिन यह अजीब है कि सी ++ 17 में हमने इस क्षेत्र में प्रगति नहीं देखी है, यह केवल सी ++ 20 में दिखाई देगा । उदाहरण के लिए, अद्भुत एसटीडी :: एल्गोरिदम पाते हैं कि कॉन्स्ट्रेक्स हस्ताक्षर नहीं मिले ।

लेकिन डरो मत! जैसा कि बेन और जेसन ने समझाया, आप आसानी से एल्गोरिदम को वर्तमान कार्यान्वयन को कॉपी करके कॉन्स्टैक्स में बदल सकते हैं (लेकिन कॉपीराइट के बारे में मत भूलना); cppreference अच्छा है। देवियों और सज्जनों, मैं आपके ध्यान में प्रस्तुत करता हूंconstexpr std :: खोजें :

 template<class InputIt, class T> constexpr InputIt find(InputIt first, InputIt last, const T& value) // ^ !!!    constexpr. { for (; first != last; ++first) { if (*first == value) { return first; } } return last; } //  http://en.cppreference.com/w/cpp/algorithm/find 

मैं पहले से ही अनुकूलन प्रशंसकों की चीखें सुन सकता हूं! हाँ, केवल cppreference द्वारा उपलब्ध कराए गए नमूना कोड के सामने स्थिरांक जोड़ने से हमें रनटाइम पर आदर्श गति नहीं मिल सकती है । लेकिन अगर हमें इस एल्गोरिथ्म में सुधार करना है, तो संकलन समय पर गति के लिए इसकी आवश्यकता होगी । जहां तक ​​मुझे पता है, जब संकलन की गति की बात आती है , तो सरल समाधान सर्वोत्तम हैं।

गति और कीड़े:

किसी भी एएए गेम के डेवलपर्स को इन समस्याओं को हल करने में निवेश करना चाहिए, है ना?

गति:

जब मैं मेटा क्रश सागा का आधा काम करने वाला संस्करण बनाने में कामयाब रहा , तो काम सुगम हो गया। वास्तव में, मैं अपने पुराने लैपटॉप पर 3 एफपीएस (फ्रेम प्रति सेकंड) से थोड़ा अधिक हासिल करने में कामयाब रहा, जिसके साथ i5 ओवरक्लॉक किया गया 1.80 गीगाहर्ट्ज़ (इस मामले में आवृत्ति महत्वपूर्ण है)। किसी भी परियोजना के रूप में, मुझे जल्दी से एहसास हुआ कि पहले लिखा कोड घृणित था, और कॉन्स्ट्रेक्स_स्ट्रिंग और मानक एल्गोरिदम का उपयोग करके खेल की स्थिति के पार्सिंग को फिर से लिखना शुरू कर दिया । हालांकि इसने कोड को बनाए रखने के लिए और अधिक सुविधाजनक बना दिया, परिवर्तनों ने गति को गंभीरता से प्रभावित किया; नई छत 0.5 एफपीएस है ।

C ++ के बारे में पुरानी कहावत के बावजूद, "शून्य-सिर अमूर्तताएं" संकलन-समय की गणनाओं पर लागू नहीं होती हैं। यह काफी तार्किक है अगर हम संकलक को कुछ "संकलन समय कोड" के व्याख्याकार के रूप में मानते हैं। विभिन्न संकलक के लिए सुधार अभी भी संभव है, लेकिन हमारे लिए विकास के अवसर भी हैं, ऐसे कोड के लेखक। यहाँ टिप्पणियों और युक्तियों की एक अधूरी सूची है, जो संभवतः GCC के लिए विशिष्ट हैं:

• C सरणियाँ std :: array से बहुत बेहतर काम करती हैं । std :: array , C-style array के शीर्ष पर आधुनिक C ++ कॉस्मेटिक्स का एक सा है और आपको ऐसी परिस्थितियों में इसका उपयोग करने के लिए एक कीमत चुकानी होगी।
• , ( ) . , , , . : , , , , ( ) , .
• , . , .
• . GCC. , «».

:

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

हमारा पहला दोस्त static_assert होगा , जो हमें संकलन समय के बूलियन मान की जांच करने का अवसर देता है। हमारा दूसरा मित्र एक मैक्रो होगा जो जहां भी संभव हो, वहां कब्जे को सक्षम और अक्षम करता है:

 #define CONSTEXPR constexpr //      //  #define CONSTEXPR //     

इस मैक्रो के साथ, हम तर्क कार्य को रनटाइम पर कर सकते हैं, जिसका अर्थ है कि हम डिबगर को इसमें संलग्न कर सकते हैं।

मेटा क्रश सागा II - पूरी तरह से रनटाइम पर गेमप्ले के लिए प्रयास करें:

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


उर्फ सराज़ के साथ पागल आदमी ने भाषा में static_print के निर्माण को जोड़ने के लिए GCC को बढ़ाया । इस निर्माण को कई स्थिर अभिव्यक्तियों या स्ट्रिंग शाब्दिकों को लेना चाहिए और उन्हें संकलन चरण में आउटपुट करना चाहिए। मुझे खुशी होगी अगर इस तरह के एक उपकरण को मानक में जोड़ा गया, या कम से कम विस्तारित static_assert ताकि यह निरंतर अभिव्यक्तियों को स्वीकार करे । हालाँकि, C ++ 17 में, इस परिणाम को प्राप्त करने का एक तरीका हो सकता है। कंपाइलर पहले से ही दो चीजों का उत्पादन करते हैं - त्रुटियां और चेतावनी ! अगर हम किसी तरह अपनी जरूरतों के लिए चेतावनी को प्रबंधित या बदल सकते हैं, तो हम पहले से ही एक योग्य निष्कर्ष प्राप्त करेंगे। मैंने विशेष रूप से कई समाधानों की कोशिश की

पदावनत की गई विशेषता :

 template <char... words> struct useless { [[deprecated]] void call() {} // Will trigger a warning. }; template <char... words> void output_as_warning() { useless<words...>().call(); } output_as_warning<'a', 'b', 'c'>(); // warning: 'void useless<words>::call() [with char ...words = {'a', 'b', 'c'}]' is deprecated // [-Wdeprecated-declarations] 

हालांकि आउटपुट स्पष्ट रूप से मौजूद है और इसे पार्स किया जा सकता है, दुर्भाग्य से, कोड अप्रयुक्त है! यदि, शुद्ध संयोग से, आप C ++ प्रोग्रामर के एक गुप्त समाज के सदस्य हैं, जो संकलन के दौरान आउटपुट का प्रदर्शन कर सकते हैं, तो मुझे आपकी टीम को सही मेटा क्रश सागा II बनाने में खुशी होगी !

निष्कर्ष:

मैंने आपको अपना घोटाला खेल बेचना समाप्त कर दिया । मुझे उम्मीद है कि आपको यह पोस्ट उत्सुक लगी होगी और इसे पढ़ने की प्रक्रिया में कुछ नया सीखने को मिलेगा। यदि आप लेख को सुधारने के लिए त्रुटियां या तरीके ढूंढते हैं, तो मुझसे संपर्क करें।

मैं स्वीडन प्रोजेक्ट टीम को धन्यवाद देना चाहता हूं कि मुझे उनके किसी कार्यक्रम में अपनी परियोजना रिपोर्ट का संचालन करने दिया। इसके अलावा, मैं अलेक्जेंडर गुरदेव के प्रति अपनी गहरी कृतज्ञता व्यक्त करना चाहता हूं , जिन्होंने मुझे मेटा क्रश गागा के महत्वपूर्ण पहलुओं को बेहतर बनाने में मदद की ।