गरीब अलेक्जेंड्रेस्कु के बारे में, मैं एक शब्द कहूंगा

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

समस्या

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

और अचानक मैंने सोचा - मुझे खुद ऐसा कार्यक्रम क्यों नहीं लिखना चाहिए? तथ्य की बात के रूप में, और सभी व्यवसाय - पढ़ने / लिखने पर, खुले / बंद कार्य हम बाहरी फाइल पर लिखने का एक अतिरिक्त कार्य लटकाते हैं। और वहां, #define का उपयोग करते हुए, हम इन कार्यों को अक्षम कर देते हैं जब उनकी आवश्यकता नहीं होती है।

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

वहां और वहां दोनों ने एक सामान्य तार्किक प्रोटोकॉल का उपयोग किया - संदेश में एक निषिद्ध चरित्र है, जो पैकेट की शुरुआत / समाप्ति का संकेत है।

और अब, अलेक्जेंड्रेस्कु की इस पुस्तक ने मेरी आंख को पकड़ लिया। मेरे सिर में घंटी बजी कि कुछ यहाँ हलचल कर सकता है ...

वास्तव में, मैं एक एकल आधार वर्ग बनाना चाहता था जो इसी तार्किक प्रोटोकॉल को लागू करता है। इस वर्ग को एक्सचेंज की भौतिक प्रकृति को भी निर्दिष्ट करना होगा - यूएसबी, इंटरप्रोसेस एक्सचेंज (यह विंडोज में था, मेमोरी मैपिंग का उपयोग किया गया था), लोकल एरिया नेटवर्क एक्सचेंज (पाइप्स का नाम), ग्लोबल एक्सचेंज (सॉकेट्स)। मैं डिबगिंग फंक्शन भी करना चाहता था। मैं भी चाहता था ...

समस्या का बयान

इसलिए, हमें एक आधार वर्ग बनाने की आवश्यकता है जो निम्नलिखित गुणों (या "नीतियों") के साथ निर्धारित हो:

• भौतिक प्रकृति - किस संचार विधि का उपयोग किया जाता है। अब मैंने FTDI से USB शेयरिंग, मेमोरी, मैपिंग पाइप, सॉकेट्स को लागू किया है। मैं यहां COM पोर्ट पर एक एक्सचेंज जोड़ना चाहूंगा;
• प्रसंस्करण विधि - शुरुआत में यह केवल फ़ंक्शन था "क्या कोई इनपुट है?", "क्या कोई आउटपुट है", "संचार की स्थिति क्या है?" फिर, जब मैंने गहन अतुल्यकालिक विनिमय के लिए एक कार्यक्रम लिखा, तो मैंने एक मल्टीटास्क एक्सचेंज एल्गोरिदम लागू किया। तो, अब मेरे पास कॉलिंग विधि के लिए 2 अलग-अलग नीतियां हैं - कार्यात्मक और मल्टीथ्रेडेड;
• विनिमय सुरक्षा - यह मत भूलो कि मेरा कार्यक्रम एक मल्टीटास्किंग वातावरण में काम करता है और विभिन्न धागे एक साथ एक्सचेंज डिवाइस तक पहुंच सकते हैं। या शायद नहीं। इसलिए, हमें एक और "विमान" मिलता है - एकल-कार्य (सरल मामलों में), महत्वपूर्ण खंडों द्वारा सुरक्षा। यदि आवश्यक हो, तो मैं म्यूटेक्स के साथ सुरक्षा बनाऊंगा, लेकिन अभी तक कोई आवश्यकता नहीं है;
• फ़ाइल करने के लिए रिपोर्ट करें - क्या यह आवश्यक है या नहीं? यदि आवश्यक हो - किस रूप में? मैंने एक विकल्प बनाया जो एक सीमांकित पाठ फ़ाइल लिखता है। यह एक्सेल और अन्य समान कार्यक्रमों के लिए आसानी से निर्यात किया जाता है;
• समय माप - कभी-कभी पैकेट के बीच के समय के अंतराल को जानना महत्वपूर्ण होता है। उन्हें विभिन्न तरीकों से मापा जा सकता है (कार्य के आधार पर)। मैंने एक मोटा समय माप (GetTicksCount), सटीक (विंडोज पर उच्च-सटीक टाइमर) और अल्ट्रा-सटीक ( आरडीटीसीटी टाइमर) बनाया।

और सबसे महत्वपूर्ण, केवल पहली दो नीतियां महत्वपूर्ण हैं - संचार की प्रकृति और जिस तरह से संचार की घटनाओं को संसाधित किया जाता है। बाकी सभी चीजों को नजरअंदाज किया जा सकता है। इसलिए, मेरे पास एक "खाली" नीति है - एक ऐसा जो कुछ भी नहीं करता है।

हां, एक और बात - यह वर्ग एक सार्वभौमिक समाधान होने का दावा नहीं करता है। हम विभिन्न तरीकों और वर्गों को गतिशील रूप से जोड़ने के बारे में बात नहीं कर रहे हैं। सभी वैश्विक सेटिंग्स को कार्यक्रम के एक स्थान पर लागू किया जाना चाहिए - और काम के पूरे समय के लिए नहीं बदलना जारी रखना चाहिए।

क्या हुआ?

परिणामस्वरूप, इंटरकनेक्ट टेम्पलेट वर्ग बनाया गया था:

template < typename Phys, // physical layer of connection - shared memory, USB, RS-232, LAN... typename Call, // call mode - function style, thread with events typename Prot = NoStrategy, // protection layer - protection based on critical sections, multiprocess protection etc. typename Log = NoStrategy, // logging mode - no logging (default), to file, to external process typename Timer = NoStrategy // timer mode - no timer (default), based on GetTickCount, high frequency timer, RDTSC > class InterConnect { protected: Phys _phys; Call _call; Prot _prot; Log _log; Timer _timer; // ... }; 

कक्षा के शरीर में, मैं हमेशा जांचता हूं कि इस नीति का उपयोग किया जाता है या नहीं। उदाहरण के लिए, बाइट राइट फ़ंक्शन कैसे लागू किया जाता है:
UPD - अपवाद थे, हटाए गए

 template <typename Phys, typename Call, typename Prot, typename Log, typename Timer> bool InterConnectStorage<Phys,Call,Prot,Log,Timer>::send_byte (const unsigned char Val) { byte val; bool res = true; Prot::ProtectByte pr (_prot); // ... res &= _call.send (_phys, Val); // ... if (Log::to_use ()) { if (Timer::to_use ()) { _timer.stamp (); _log.send (Val, _timer.dprev (), _timer.dstart (), res); } else _log.send (Val, 0, 0, res); return res; } } 

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

हर जगह एक चेक है - क्या यह पॉलिसी इस्तेमाल की गई है या नहीं? स्थैतिक कार्य bool to_use (void) इस प्रश्न का उत्तर देता है। इस तथ्य के कारण कि यह स्थिर और बहुत सरल है, संकलक कोड को अनुकूलित कर सकता है - या तो इसे बिल्कुल न बनाएं (यदि नीति का उपयोग नहीं किया गया है) या तुरंत इसे बिना जांच के कॉल करें।

नतीजतन, काफी बोझिल सी ++ कोड कोडांतरक में काफी सरल और इष्टतम हो जाता है।

के उपयोग

नतीजतन, मुझे एक बहुत सुविधाजनक उपकरण मिला जो बहुत कम कोड के साथ कॉन्फ़िगर किया गया है।

यहाँ एक छोटा USB साझाकरण कार्यक्रम का एक उदाहरण दिया गया है:

 typedef InterConnectStrat::FTDIAccess Phys; //   typedef InterConnectStrat::ThreadCall <Phys> Call; //   typedef InterConnectStrat::CritSectProtectPack Prot; //   typedef InterConnectStrat::NoStrategy Timer; //    #if defined (MakeLogFile) typedef InterConnectStrat::TabulatedASCIILogFile Log; //    File _log; //   #else typedef InterConnectStrat::NoStrategy Log; //    #endif InterConnectStorage <Phys, Call, Prot, Log, Timer> _con; //    

MakeLogFile स्थिर के साथ, मैं पूरी तरह से कार्यक्रम के तर्क को बदल देता हूं। पुनरावर्तन, बेशक, समय लगता है, लेकिन परिणामी कोड बहुत प्रभावी है - गति और संसाधनों दोनों के साथ-साथ कार्यक्षमता के मामले में।

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

रास्ते के साथ, मैंने संदेश के लिए कार्यक्रम की प्रतिक्रिया पर काम किया। ऐसा करने के लिए, मैंने USB से एक्सचेंज की प्रकृति को इंटरप्रोसेस में बदल दिया। मैंने एक दूसरा कंसोल सरल अनुप्रयोग बनाया जिसमें मुझे आवश्यक पैकेज भेजे गए। और इसलिए मैंने मुख्य कार्यक्रम की प्रतिक्रिया को दाईं ओर बांधा। फिर, फिर से, मैंने टाइपडिफ भौतिकी को बदल दिया और कार्यक्रम के एक स्थान (अधिकतम 5 पंक्तियों) में संचार मापदंडों को सेट किया - और सब कुछ यूएसबी के साथ काम करना शुरू कर दिया। बहुत सरल और सुविधाजनक!

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

 // .   _con++; _con <<= SetProgramDate; _con <<= _HEX_date.get_Unix_time (); --_con; // .     _con++; _con <<= GotoProgram; --_con; 

कोड अपने लिए बोलता है।

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

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

अन्य तरीकों की तुलना

और अब मज़े के लिए, C ++ 9x का उपयोग करके उसी समस्या को हल करने के अन्य तरीकों पर विचार करें। मुझे कमेंट में बताएं कि मैं क्या चूक गया:

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

सामान्य तौर पर, उपकरण बहुत सुविधाजनक और उच्च गुणवत्ता वाला निकला। यह आपको पूरी तरह से अलग विमानों में अपनी कार्यक्षमता विकसित करने की अनुमति देता है।

पीएस अलेक्जेंड्रेस्कु - अच्छा किया, जो कुछ भी कहेंगे!