👗 👨🏾‍🎤 💑 संकलन के समय जीवन 🕍 ❕ 👂

लेख इस बारे में नहीं है कि परियोजना क्या चल रही है।

वाक्यांश "टेम्प्लेट भरा हुआ है, ट्यूरिंग-पूर्ण, भाषा" अक्सर अविश्वास के साथ माना जाता है। यह आधुनिक प्रोग्रामिंग भाषाओं की एक सामान्यीकरण विशेषता है, कंप्यूटिंग शक्ति कहाँ से आती है? तो मैंने सोचा। अब मैं मेरे जैसे शुरुआती लोगों के लिए टेम्प्लेट के काम के सिद्धांतों को समझाने के साथ, बाकी को भी समझाना चाहता हूं।

C ++ के निर्माता से C ++ के बारे में एक पुस्तक के अध्याय "मेटाप्रोग्रामिंग" को पढ़ने के बाद पहली बार टेम्प्लेट की मेरी समझ हिल गई थी - ऐसा लगता था कि वे वास्तव में एक प्रोग्रामिंग भाषा के अंदर एक पूर्ण प्रोग्रामिंग भाषा हो सकते हैं। किसी भी मामले में, निश्चित रूप से पुनरावृत्ति है। लेकिन खुद को कुछ साबित करने का सबसे अच्छा तरीका यह है कि हम जो करेंगे, उसे करने की कोशिश करें।

जॉन कॉनवे द्वारा प्रसिद्ध खेल "लाइफ" के कई अहसास हैं, पागल और ऐसा नहीं है। लेकिन उन सभी में एक सामान्य घातक दोष है: जीवन के प्रत्येक पुनरावृत्ति की गणना सीधे कार्यक्रम संचालन के दौरान की जाती है । चलो इसे ठीक करने की कोशिश करते हैं।

पैटर्न क्या हैं

यह एक भाषा तंत्र है जो आपके लिए विशिष्ट प्रकार के डेटा \ _ प्रकार बनाता है, जिससे आप सामान्यीकृत एल्गोरिदम, डेटा संरचना और जैसे लिख सकते हैं - प्रोग्रामर वांछित पैरामीटर को प्रतिस्थापित करेगा, और संकलक, टेम्पलेट द्वारा, संबंधित इकाई बनाएगा।

template <typename T> class SomeClass { T i; }; template <class T> // class  —   ,   typename! T sum( T a, T b ) { return a + b; } SomeClass<int> obj_1; SomeClass<double> obj_1; double i = sum<double>( 3.14, 15.9 );

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

आप "भरा नहीं जा सकता है" वर्ग के टाइप के नाम के सामने मिस्ड जगह के नाम को निर्दिष्ट करके, या सीधे क्लास के टाइपनेम के बजाय सीधे टाइप करके निर्दिष्ट नहीं कर सकते हैं।

हालांकि टेम्प्लेट भाषा में टाइपनेम और क्लास का बिल्कुल समान अर्थ है, आप कोड की समझ को आसान बनाने के लिए लिखित में अंतर का उपयोग कर सकते हैं - उदाहरण के लिए, टाइपनेम का उपयोग करें जहां न केवल जटिल, बल्कि सरल डेटा प्रकार भी मापदंडों (सादे पुराने) के रूप में उपयोग किए जा सकते हैं डेटा), और वर्ग - जहां बेहद जटिल "वयस्क" कक्षाएं अपेक्षित हैं।

क्या वह सब है?

सामान्य तौर पर, हां, यह पर्याप्त है।

यह भी वांछनीय है कि संकलक C ++ 11 मानक का अनुपालन करता है और संकलन चरण में सरल कार्यों वाले निरंतर अभिव्यक्तियों के परिणामों की गणना करने में सक्षम है।

लेकिन कोड को सरल बनाने के लिए, हमें प्रकारों के लिए उपनामों की आवश्यकता है। C ++ कुछ जटिल चीज़ों को सरल कहने के लिए 2 मैकेनिज्म प्रदान करता है: टाइपडीफ और उपयोग करना। उत्तरार्द्ध C ++ 11 में दिखाई दिया और एक अधिक समझदार वाक्यविन्यास और टेम्पलेट समर्थन के साथ typedef (जो C का अवशेष है) से अलग है:

 // ,  "" —      typedef std::vector<string> Strings; //  using Strings = std::vector<string>; //  //     typedef void (*FunctionType)(double); //    using FunctionType = void (*)(double); // FunctionType —   ,  double,  void // ,   —   ,    T template <typename T> typedef Matrix<T, 3> Cube<T>; //   template <typename T> using Cube = Matrix<T, 3>; //

इसलिए, टाइपिंगडिफ का अधिक समझ और विस्तारित संस्करण का उपयोग करना है। टाइप्डिफ के बारे में जानते हैं, लेकिन उपयोग करके देखें।

जीवन क्या है?

गेम लाइफ - मैदान पर कोशिकाओं के जीवन का एक सिम्युलेटर। जीवन के नियमों के कई रूप हैं, लेकिन हम क्लासिक का उपयोग करते हैं। यदि दो से कम पड़ोसी हैं, या तीन से अधिक पड़ोसी हैं, तो भुखमरी से जीवित कोशिका की मृत्यु हो जाती है। एक खाली सेल में, जीवन तभी शुरू होता है जब उसके बगल में 3 जीवित कोशिकाएं होती हैं, अर्थात। माता-पिता और प्रसूति विशेषज्ञ हैं।

आइए हम समस्या का विश्लेषण करते हैं: जीवन के लिए, कोशिकाओं की आवश्यकता होती है, जिस स्थान पर वे स्थित हैं, प्रत्येक सेल की अगली स्थिति का निर्धारण करने का एक तरीका, अपने पड़ोसियों की संख्या के आधार पर।

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

हम जीवन को जन्म देते हैं

शुरुआत में एक सेल थी:

 struct O { }; // dead struct X { }; // alive

और सेल प्रकार के मूल्य के लिए बाध्यकारी:

 template <typename T> //   —   constexpr bool is_alive(); template<> //      constexpr bool is_alive<O>() { return false; } template<> //     X constexpr bool is_alive<X>() { return true; }

यह स्पष्ट किया जाना चाहिए कि टेम्पलेट भाषा केवल डेटा प्रकारों और स्थिर मूल्यों के साथ काम कर सकती है, जिन्हें संकलन समय पर गणना की जा सकती है।

शब्द "कॉन्स्ट्रेप" संकलक को बताता है कि फ़ंक्शन को संकलन चरण में निष्पादित किया जाना चाहिए। यदि यह संकलक को लगता है कि यह इस फ़ंक्शन के लिए प्रदान नहीं किया जा सकता है, तो यह एक त्रुटि फेंक देगा।

फिर भी यहाँ टेम्पलेट भाषा की एक नई विशेषता खोजी गई है - विशेषज्ञता। यह आपको विशिष्ट मापदंडों के लिए विशेष प्रकार की संस्थाएं बनाने की अनुमति देता है। अत्यधिक मामलों में, पूर्ण विशेषज्ञता के साथ, जैसा कि ऊपर दिए गए उदाहरण में है, केवल कोण कोष्ठक टेम्प्लेट की सूची से बने रहते हैं।

विशेषज्ञता एक बहुत ही मौका है जो पुनरावृत्ति से बाहर निकलने के तरीके के साथ टेम्पलेट्स का समर्थन करता है। उसके बारे में - थोड़ी देर बाद।

शर्तों को शुरू करना

हम पहिया को सुदृढ़ नहीं करेंगे और एसटीएल, खेल मापदंडों से टपल का उपयोग करके खेल के मैदान को सेट करेंगे - स्थिरांक द्वारा:

 using start = tuple< O, O, O, O, O, O, O, X, O, O, O, O, O, X, O, O, X, X, X, O, O, O, O, O, O >; //   const int width = 5; const int height = 5; const int iterations = 20;

tuple - एक डेटा संरचना जिसमें विभिन्न प्रकार के डेटा हो सकते हैं - एक प्रकार का विषम सरणी। हम अनिवार्य रूप से इसमें कुछ भी संग्रहीत नहीं करेंगे - हम केवल टुपल प्रकार में रुचि रखते हैं, जिसमें पहले से परिभाषित प्रकार ओ और एक्स हैं। यह समझना महत्वपूर्ण है कि इकट्ठे कार्यक्रम में कोई मूल्य नहीं हैं, हम केवल प्रकार में रुचि रखते हैं और काम कर रहे हैं। हम केवल प्रकार के साथ हैं।

जीवित कोशिकाओं की पुनरावर्ती गिनती

चलो जादू पर चलते हैं। हमें याद है कि हमें सेल के जीवित पड़ोसियों की गिनती करने की आवश्यकता है। आइए O और X के पड़ोसियों को पहले से ही गुदगुदाएं और हम उनकी संख्या जानते हैं:

 template <typename tuple, int N> struct tuple_counter { constexpr static int value = is_alive<typename tuple_element<N, tuple>::type>() + tuple_counter<tuple, N-1>::value; }; template <typename tuple> //      N = 0 struct tuple_counter<tuple, 0> { constexpr static int value = is_alive<typename tuple_element<0, tuple>::type>(); };

यहां क्या हो रहा है? प्रत्यावर्तन! आइए करीब से देखें:

 constexpr static int value = is_alive<typename tuple_element<N, tuple>::type>() + // …

हम पहले ही कॉन्स्टैक्स से मिल चुके हैं - मूल्य की गणना संकलन स्तर पर की जाती है और स्थिर होती है।
tuple_element <N, tuple> - जाहिर है, tuple से Nth तत्व का चयन, STL में प्रदान किया गया अवसर।

टाइपनेम और :: टाइप क्यों है? प्रकार tuple_element संरचना का क्षेत्र है, जो किसी अन्य प्रकार का एक टाइप्डिफ उपनाम है, और टाइपनेम, मोटे तौर पर बोल रहा है, विशेष रूप से संकलक को बताता है कि यह टेम्पलेट प्रकार का नाम है।
यहाँ टाइपनेम के बारे में अधिक।

 … + tuple_counter<tuple, N-1>::value;

और यहाँ पुनरावृत्ति ही है। मान की गणना करने के लिए, tuple_counter समान tuple_counter के मान का उपयोग करता है, केवल एक पुनरावृत्ति संख्या 1 कम के साथ। रिकर्सन से बाहर निकलना तब होगा जब N 0. हो जाएगा। कंपाइलर N = 0 के लिए विशेष रूप से tuple_counter टेम्प्लेट पर ठोकर खाएगा, जिसमें कोई रिकर्सन नहीं है, और अंतिम मान की गणना करें। हो गया।

खेल में अन्य सभी गणना, साथ ही परिणाम का आउटपुट, उसी सिद्धांत के अनुसार किया जाता है - पुनरावर्ती।

कोशिका की अगली अवस्था का निर्धारण

ठीक है, मान लीजिए कि हमने जीवित पड़ोसियों की गिनती की - हम इसके आधार पर एक सेल की अगली स्थिति का पता कैसे लगा सकते हैं? बहुत आसान है अगर आप पहिया को मजबूत नहीं करते हैं और एसटीएल से सशर्त का उपयोग करते हैं:

 template <typename point, typename neighbors> struct calc_next_point_state { constexpr static int neighbor_cnt = tuple_counter<neighbors, tuple_size<neighbors>() - 1>::value; using type = typename conditional < is_alive<point>(), typename conditional < (neighbor_cnt > 3) || (neighbor_cnt < 2), O, X >::type, typename conditional < (neighbor_cnt == 3), X, O >::type >::type; };

टर्नेरी ऑपरेटर X का सशर्त एनालॉग? Y: Z. यदि पहले पैरामीटर में स्थिति सही है, तो दूसरा पैरामीटर, अन्यथा तीसरा है। बाकी कोड, मुझे लगता है, अब स्पष्टीकरण की आवश्यकता नहीं है।

खेल का मैदान

महान - हमारे पास एक प्रारंभिक खेल का मैदान है और उस पर किसी भी सेल के लिए अगले राज्य का निर्धारण करने का एक तरीका है। जीवन को आसान बनाएं और जीवन के सभी बुनियादी कार्यों को एक स्थान पर संयोजित करें:

 template <typename initial_state> struct level { template <int N> //     using point = typename tuple_element<N, initial_state>::type; template <int N> // (  )     using neighbors = tuple< point< /* */ >, ... >; template <int N> //     using next_point_state = typename calc_next_point_state<point<N>, neighbors<N>>::type; };

पड़ोसी सूचकांक की गणना करते समय गलतियां न करने की कोशिश करें - यदि आप ट्यूल से परे जाते हैं, तो आपको लगभग 56 अस्पष्ट संकलन त्रुटियां मिलेंगी, यह क्षेत्र के आकार और पुनरावृत्तियों की संख्या पर निर्भर करता है।

अगले क्षेत्र राज्य की गणना

आगे समाधान स्पष्ट है - हम सभी कोशिकाओं के माध्यम से जाएंगे, एक सरणी में प्रत्येक की अगली स्थिति को बचाएंगे, परिणाम प्रिंट करेंगे, सभी पुनरावृत्तियों के लिए दोहराएंगे ... सरणी? हमारे पास कोई ऐरे नहीं है। आप केवल व्यक्तिगत मूल्यों को टूप्ले में नहीं डाल और डाल सकते हैं - हम केवल प्रकारों के साथ काम करते हैं, और टपल में एक व्यक्तिगत तत्व के प्रकार को बदलना संभव नहीं है।

क्या करें? Tuple_cat का उपयोग करें - एक में कई tuple के संयोजन के लिए एक भाषा तंत्र। दुर्भाग्य से, tuple_cat tuple मान लेता है, और फिर, हम केवल प्रकारों में रुचि रखते हैं। आप एसटीएल स्रोतों को देख सकते हैं और पता लगा सकते हैं कि tuple_cat किस प्रकार को निर्धारित करता है, अपने स्वयं के tupleciped का आविष्कार करें, या उपलब्ध भाषा टूल का उपयोग करें।

सौभाग्य से, घोषणापत्र ऑपरेटर C ++ 11 में दिखाई दिया, जिसका शाब्दिक अर्थ है "यदि हम इसे कहते हैं तो फ़ंक्शन किस प्रकार वापस आएगा"। हम इसे tuple_cat पर लागू करते हैं और ... सुनिश्चित करें कि tuple_cat अभी भी नंगे प्रकार "tuple" को स्वीकार नहीं करता है जिसके साथ हम हर जगह काम करते हैं, लेकिन tuple का मान। सौभाग्य से, C ++ में एक घोषणा वर्ग है जो हमें यह दिखावा करने की अनुमति देता है कि एक मूल्य मौजूद है, लेकिन इसका उपयोग मूल्य के रूप में कहीं और नहीं किया जा सकता है। इतना ही काफी है।

 template <typename tuple_1, typename tuple_2> struct my_tuple_cat { //     tuple_cat,        tuple,    ? using result = decltype( tuple_cat( declval<tuple_1>(), declval<tuple_2>() ) ); };

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

 template <typename field, int iter> struct next_field_state { template<int N> using point = level<field>::next_point_state<N>; using next_field = typename my_tuple_cat < tuple< point<point_count - iter> >, typename next_field_state<field, iter-1>::next_field >::result; }; template <typename field> struct next_field_state<field, 1> { template<int N> using point = level<field>::next_point_state<N>; using next_field = tuple< point<point_count - 1> >; };

परिणाम के सही क्रम के लिए स्ट्रेंज पॉइंट इंडेक्सिंग की आवश्यकता होती है। हो गया। हमने जीवन की अगली स्थिति की गणना एक ऐसे रूप में की है जिसमें इसे गणना के अगले चक्र में भेजा जा सकता है। यह केवल परिणाम प्रदर्शित करने के लिए बनी हुई है।

आउटपुट परिणाम

आउटपुट फ़ंक्शंस कोई नया ज्ञान नहीं रखते हैं, इसलिए मैं उन्हें स्पॉइलर के नीचे लाता हूं।

आउटपुट फ़ंक्शन

 template <typename Type> void print(); template<> void print<O>() { cout << "O"; } template<> void print<X>() { cout << "X"; } template <typename tuple, int N> struct Printer { static void print_tuple() { Printer<tuple, N-1>::print_tuple(); if( N % width == 0 ) cout << endl; print<typename tuple_element<N, tuple>::type>(); } }; template <typename tuple> struct Printer<tuple, 0> { static void print_tuple() { print<typename tuple_element<0, tuple>::type>(); } }; template <typename field, int iters> struct game_process { static void print() { Printer< field, point_count - 1 >::print_tuple(); cout << endl << endl; game_process< typename next_field_state<field, point_count>::next_field, iters-1 >::print(); } }; template <typename field> struct game_process<field, 0> { static void print() { Printer< field, point_count - 1 >::print_tuple(); cout << endl; } };

निष्कर्ष में

यह प्रारंभिक क्षेत्र, स्रोत में पुनरावृत्तियों की संख्या और जीवन में सांस लेने के लिए रहता है, जो कि जीवन शुरू होने से पहले ही पूरी तरह से निर्धारित किया गया था।

 int main() { game_process< start, iterations >::print(); return 0; }

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

जीवन अपने आप में एक संपूर्ण भाषा है। इसलिए, खेल जीवन में, सी + + 11 संकलक के साथ जीवन स्रोत के लिए सी ++ 11 संकलक का निर्माण करना सैद्धांतिक रूप से संभव है ... मैं एक स्वतंत्र समाधान के लिए अमर पाठकों को ऊब करने के लिए इस कार्य को छोड़ देता हूं।

GitHub पर एक कार्यशील परियोजना का पृष्ठ।
संदर्भ: C ++ प्रोग्रामिंग लैंग्वेज, 4th एडिशन ।

संकलन के समय जीवन