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

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

इस बार मैं प्रश्न 4 को देखना चाहूंगा।

यहाँ उसका कोड है। थोड़ा कंघी की ताकि वह जा रहे थे

#include <string> #include <stdexcept> #include <iostream> class CodeGenerator { public: enum Lang {JAVA, C_PLUS_PLUS, PHP}; CodeGenerator(Lang language) { _language=language; } std::string generateCode() { switch(_language) { case JAVA: return std::string("Java: System.out.println(\"Hello world!\");"); case C_PLUS_PLUS: return std::string("C++: std::cout << \"Hello world!\";"); } throw new std::logic_error("Bad language"); } std::string someCodeRelatedThing() // used in generateCode() { switch(_language) { case JAVA: return std::string("http://www.java.com/"); case C_PLUS_PLUS: return std::string("http://www.cplusplus.com/doc/tutorial/"); } throw new std::logic_error("Bad language"); } private: Lang _language; }; int main() { CodeGenerator cg(CodeGenerator::JAVA); std::cout << cg.generateCode() << "\tMore info: " << cg.someCodeRelatedThing() << std::endl; CodeGenerator ec(CodeGenerator::PHP); try { ec.generateCode(); } catch (std::logic_error * e) { std::cout << "ERROR: " << e->what() << std::endl; } return 0; }

आइए रेखांकित करें कि हम यहां से क्या निकालना चाहते हैं:

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

हम क्रमिक रूप से आगे बढ़ेंगे। यह बहुत सारे अक्षर निकला, लेकिन वे सभी सरल हैं और, मुझे आशा है, मस्तिष्क के अत्यधिक प्रयास की आवश्यकता नहीं होगी। अपने पसंदीदा पेय को डालें और आगे बढ़ें।

फूट डालो और राज करो

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

 #include <string> #include <stdexcept> #include <iostream> class CodeGeneratorJavaProcessor { public: std::string code() { return std::string("Java: System.out.println(\"Hello world!\");"); } std::string thing() { return std::string("http://www.java.com/"); } }; class CodeGeneratorCppProcessor { public: std::string code() { return std::string("C++: std::cout << \"Hello world!\";"); } std::string thing() { return std::string("http://www.cplusplus.com/doc/tutorial/"); } }; class CodeGenerator { public: enum Lang {JAVA, C_PLUS_PLUS, PHP}; CodeGenerator(Lang language) { _language=language; } std::string generateCode() { switch(_language) { case JAVA: return CodeGeneratorJavaProcessor().code(); case C_PLUS_PLUS: return CodeGeneratorCppProcessor().code(); } throw new std::logic_error("Bad language"); } std::string someCodeRelatedThing() { switch(_language) { case JAVA: return CodeGeneratorJavaProcessor().thing(); case C_PLUS_PLUS: return CodeGeneratorCppProcessor().thing(); } throw new std::logic_error("Bad language"); } private: Lang _language; }; int main() { CodeGenerator cg(CodeGenerator::JAVA); std::cout << cg.generateCode() << "\tMore info: " << cg.someCodeRelatedThing() << std::endl; CodeGenerator ec(CodeGenerator::PHP); try { ec.generateCode(); } catch (std::logic_error * e) { std::cout << "ERROR: " << e->what() << std::endl; } return 0; }

हम इस विशुद्ध यांत्रिक सुधार पर चर्चा करने से पीछे नहीं हटेंगे।

एकीकृत इंटरफ़ेस और एकाधिक स्विच विफलता

आइए सभी भाषाओं के लिए एक एकल इंटरफ़ेस बनाएं। अब हम CodeGenerator में भाषा कोड नहीं, बल्कि उस भाषा के एक जनरेटर वर्ग के लिए एक पॉइंटर रख सकते हैं। भाषा कोड को कक्षा में परिवर्तित करना एक बार होता है।

 #include <string> #include <stdexcept> #include <iostream> class CodeGeneratorAbstractProcessor { public: virtual std::string code() = 0; virtual std::string thing() = 0; virtual ~CodeGeneratorAbstractProcessor() {} }; class CodeGeneratorJavaProcessor : public CodeGeneratorAbstractProcessor { public: std::string code() { return std::string("Java: System.out.println(\"Hello world!\");"); } std::string thing() { return std::string("http://www.java.com/"); } }; class CodeGeneratorCppProcessor : public CodeGeneratorAbstractProcessor { public: std::string code() { return std::string("C++: std::cout << \"Hello world!\";"); } std::string thing() { return std::string("http://www.cplusplus.com/doc/tutorial/"); } }; class CodeGeneratorBadProcessor : public CodeGeneratorAbstractProcessor { public: std::string code() { throw new std::logic_error("Bad language"); return std::string(); } std::string thing() { throw new std::logic_error("Bad language"); return std::string(); } }; class CodeGenerator { public: enum Lang {JAVA, C_PLUS_PLUS, PHP}; CodeGenerator(Lang language) : processor(0) { switch(language) { case JAVA: processor = new CodeGeneratorJavaProcessor(); break; case C_PLUS_PLUS: processor = new CodeGeneratorCppProcessor(); break; case PHP: processor = new CodeGeneratorBadProcessor(); break; } } ~CodeGenerator() { delete processor; } std::string generateCode() { return processor->code(); } std::string someCodeRelatedThing() { return processor->thing(); } private: CodeGeneratorAbstractProcessor * processor; }; int main() { CodeGenerator cg(CodeGenerator::JAVA); std::cout << cg.generateCode() << "\tMore info: " << cg.someCodeRelatedThing() << std::endl; CodeGenerator ec(CodeGenerator::PHP); try { ec.generateCode(); } catch (std::logic_error * e) { std::cout << "ERROR: " << e->what() << std::endl; } return 0; }

जैसा कि मैं इसे समझता हूं, यह ठीक ऐसे डिजाइन के बारे में था जिसका मेरे पिछले नोट के जवाब में उल्लेख किया गया था। लेखक को संदेह था कि कुछ और भी सुधार किया जा सकता है। खैर, चलिए देखते हैं।

लेकिन क्या हम चीजों के बारे में अपना नजरिया नहीं बदलते हैं?

आइए देखें कि CodeGenerator अब क्या करता है। बस दो चीजें:

कंवर्टर में ऑब्जेक्ट को एनम परिवर्तित करता है
एक ऑब्जेक्ट पर एक आवरण प्रदान करता है जो सभी काम करता है

क्या हमें ऐसे वर्ग की आवश्यकता है? आइए इस प्रश्न को अभी के लिए खुला छोड़ दें और देखें कि इस वर्ग का उपयोग कैसे किया जाना चाहिए। जाहिर है, कुछ इस तरह:

 void i_like_to_convert_enum_to_lang(CodeGenerator::Lang lang_code) { CodeGenerator cg(lang_code); std::cout << cg.generateCode() << "\tMore info: " << cg.someCodeRelatedThing() << std::endl; }

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

 void i_like_to_use_generators(CodeGeneratorAbstractProcessor * cg) { std::cout << cg->code() << "\tMore info: " << cg->thing() << std::endl; }

यहाँ हमने वास्तव में CodeGenerator को त्याग दिया।

बेशक, इस तरह के एक निर्णायक कदम इंटरफ़ेस को बदले बिना नहीं किया जा सकता था, लेकिन हमें कितने फायदे मिले!

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

और अब विषयांतर करने का समय है।

<गीतात्मक विषयांतर>

प्रोग्रामर के बीच, सभी प्रकार के हास्केल्स के लिए प्रवण, अगर और अन्य शाखाओं के खिलाफ सेनानियों के उत्सुक आंदोलन हैं।

इफ़्स के साथ समस्या यह है कि वे संक्रमण की तरह गुणा करते हैं। मैं एक उदाहरण दूंगा जो वास्तविक जीवन में बहुत बार देखा जा सकता है। मान लीजिए कि आप डिबगिंग को सक्षम करने की क्षमता के साथ एक कार्यक्रम लिखते हैं।

अक्सर ऐसा किया जाता है:

 #include <iostream> #include <unistd.h> int main(int argc, char *argv[]) { //   ( ) bool debug(false); int r; while ((r = getopt(argc, argv, "d")) != -1) { switch ( r ){ case 'd': debug = true; break; } } //      , //     // ( ) if (debug) { std::cout << "Some debugging" << std::endl; } return 0; }

ऐसे कोड के उदाहरण cdrtools, Python, git, cmake, m4 (debug variable), firefox (debug_mode), mpalyer / mencoder (विभिन्न प्रकारों के क्षेत्र, विभिन्न संरचनाओं में b_debug), x11vnc (debug / क्रैश_debug / debug / debug / debug / debug / debug) के स्रोतों में पाए जा सकते हैं। ... अपने पसंदीदा कार्यक्रम के स्रोत कोड को देखें और आपको अतिरिक्त चित्रण मिलेंगे।

समस्या यह है कि पहला अगर एक तार्किक मूल्य को दूसरे में परिवर्तित करता है। और फिर, मुख्य कोड में, इस दूसरी तार्किक मूल्य की व्याख्या हर बार की जाती है।

यह निश्चित रूप से प्रदर्शन में कमी नहीं करता है (इसके विपरीत! प्रदर्शन के मामले में यह बहुत अच्छा दृष्टिकोण है), लेकिन यह कोड को बंद कर देता है और इसके समर्थन को बहुत जटिल बना देता है। कोड के इस सभी ढेर में गलती करना आसान है। कोड का यह गुच्छा बदलना मुश्किल है।

लेकिन, सौभाग्य से, एक और उपाय है। इस प्रकार के:

 #include <iostream> #include <unistd.h> class noout : public std::ostream {}; noout& operator<< (noout& out, const char* s) { return out; } int main(int argc, char *argv[]) { //       //    noout e; std::ostream *debug(&e); int r; while ((r = getopt(argc, argv, "d")) != -1) { switch ( r ){ case 'd': debug = &std::cout; break; } } //     *debug << "Some debugging" << std::endl; return 0; }

यहां, रूपांतरण तुरंत एक ऑब्जेक्ट में किया जाता है जो निर्धारित करता है कि डिबगिंग संदेशों के साथ क्या करना है।

कार्यक्रम के मुख्य निकाय में शाखाओं की अब आवश्यकता नहीं है।

इसके अलावा, इस कोड को विकसित करना अब बहुत आसान है। उदाहरण के लिए, हम डीबगिंग जानकारी को निर्देशित करने के लिए एक नई स्ट्रीम जोड़ सकते हैं।

 #include <iostream> #include <unistd.h> class noout : public std::ostream {}; noout& operator<< (noout& out, const char* s) { return out; } int main(int argc, char *argv[]) { //     //      noout e; std::ostream *debug(&e); int r; while ((r = getopt(argc, argv, "de")) != -1) { switch ( r ){ case 'd': debug = &std::cout; break; case 'e': debug = &std::cerr; break; } } //        //  ,     *debug << "Some debugging" << std::endl; return 0; }

बेशक, यह कार्यान्वयन केवल दृष्टिकोण को दिखाता है। बेशक मैं जोड़ना भूल गया

 noout& operator<< (noout& out, const signed char* s); noout& operator<< (noout& out, const unsigned char* s); ...

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

और, ध्यान दें, और यहां ऑब्जेक्ट एक पॉलीमॉर्फिक जीवन जीते हैं, लेकिन हमें अभी तक एक पॉलीमॉर्फिक विलोपन की आवश्यकता नहीं है (यह फिर से पिछले नोट पर लौट रहा है)।

</ गीतात्मक विषयांतर>

कार्यान्वयन से इंटरफ़ेस को अलग करें

चलिए CodeGeneratorAbstractProcessor क्लास को थोड़ा रीमेक करते हैं, साथ ही साथ NVI के कॉन्सेप्ट को प्रदर्शित करते हैं। देखें कि कार्यान्वयन इंटरफ़ेस से कैसे अलग है:

 #include <string> #include <stdexcept> #include <iostream> class CodeGeneratorAbstractProcessor { public: std::string generateCode() { return code(); } std::string someCodeRelatedThing() { return thing(); } protected: ~CodeGeneratorAbstractProcessor() {} private: virtual std::string code() = 0; virtual std::string thing() = 0; }; class CodeGeneratorJavaProcessor : public CodeGeneratorAbstractProcessor { public: std::string code() { return std::string("Java: System.out.println(\"Hello world!\");"); } std::string thing() { return std::string("http://www.java.com/"); } }; class CodeGeneratorCppProcessor : public CodeGeneratorAbstractProcessor { public: std::string code() { return std::string("C++: std::cout << \"Hello world!\";"); } std::string thing() { return std::string("http://www.cplusplus.com/doc/tutorial/"); } }; class CodeGeneratorBadProcessor : public CodeGeneratorAbstractProcessor { public: std::string code() { throw new std::logic_error("Bad language"); return std::string(); } std::string thing() { throw new std::logic_error("Bad language"); return std::string(); } }; void i_like_to_use_generators(CodeGeneratorAbstractProcessor * cg) { std::cout << cg->generateCode() << "\tMore info: " << cg->someCodeRelatedThing() << std::endl; } int main() { CodeGeneratorJavaProcessor java; i_like_to_use_generators(&java); return 0; }

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

 #include <string> #include <stdexcept> #include <iostream> class CodeGeneratorAbstractProcessor { public: std::string generateCode() { return lang() + ": " + code(); } std::string someCodeRelatedThing() { return thing(); } protected: ~CodeGeneratorAbstractProcessor() {} private: virtual std::string lang() = 0; virtual std::string code() = 0; virtual std::string thing() = 0; }; class CodeGeneratorJavaProcessor : public CodeGeneratorAbstractProcessor { public: std::string lang() { return std::string("Java"); } std::string code() { return std::string("System.out.println(\"Hello world!\");"); } std::string thing() { return std::string("http://www.java.com/"); } }; class CodeGeneratorCppProcessor : public CodeGeneratorAbstractProcessor { public: std::string lang() { return std::string("C++"); } std::string code() { return std::string("std::cout << \"Hello world!\";"); } std::string thing() { return std::string("http://www.cplusplus.com/doc/tutorial/"); } }; class CodeGeneratorBadProcessor : public CodeGeneratorAbstractProcessor { public: std::string lang() { throw new std::logic_error("Bad language"); return std::string("???"); } std::string code() { throw new std::logic_error("Bad language"); return std::string(); } std::string thing() { throw new std::logic_error("Bad language"); return std::string(); } }; void i_like_to_use_generators(CodeGeneratorAbstractProcessor * cg) { std::cout << cg->generateCode() << "\tMore info: " << cg->someCodeRelatedThing() << std::endl; } int main() { CodeGeneratorJavaProcessor java; i_like_to_use_generators(&java); return 0; }

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

इस प्रकार, हमने लेख की शुरुआत में बताई गई सभी इच्छाओं को पूरा किया। पहले से ही रुकने का समय है मैं अपनी टोपी को हर किसी के पास ले जाता हूं जो अंत तक पढ़ा है। आपका धन्यवाद

और तस्वीर एक डॉल्मेन दिखाती है, जिसका लेख से कोई लेना-देना नहीं है। यह सिर्फ वे थे जो इस विषय पर एक लेख लिखना चाहते थे।

शाखाओं में। उनके साथ क्या किया जा सकता है

फूट डालो और राज करो

एकीकृत इंटरफ़ेस और एकाधिक स्विच विफलता

लेकिन क्या हम चीजों के बारे में अपना नजरिया नहीं बदलते हैं?

कार्यान्वयन से इंटरफ़ेस को अलग करें

More articles: