10 साल का अभ्यास। भाग 1: एक कार्यक्रम का निर्माण

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





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

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



तो, सहकर्मियों, हम सी ++ में लिखते हैं। एक नियम के रूप में, इसका मतलब है कि हमारे कार्यक्रम जटिल हैं। कुछ बहुत जटिल हैं। कार्यक्रम के रूप में इसे करने के लिए काम करना चाहिए, मुझे, इसके निर्माता, यह ध्यान में रखने की आवश्यकता है कि यह कैसे काम करता है, सबसे छोटे विवरण तक। यह एक आवश्यक शर्त है, क्योंकि सभी को पूरी तरह से सोचा नहीं जा सकता है कि कीड़े की गारंटी है।



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



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



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

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



जाहिर है? बहुत बढ़िया! चलो इसे थोड़ा जटिल करते हैं और उन तत्वों के अंदर देखते हैं जो मैंने ऊपर के बारे में बात की थी ...



C ++ इस अर्थ में बहुत सरल है कि C ++ कक्षाएं अक्सर वास्तविक दुनिया में वस्तुओं का वर्णन दोहराती हैं (प्रत्यक्ष प्रतिलिपि के अर्थ में नहीं, लेकिन नामों के अर्थ में, आंशिक रूप से कार्यक्षमता और रिश्तों के अलावा, C ++ में सिंथेटिक सहायक कक्षाएं हैं) । जब कोई वास्तविक-विश्व ऑब्जेक्ट होता है या कोई अन्य वास्तविक-विश्व ऑब्जेक्ट (केवल एक) होता है, तो C ++ क्लास इनहेरिटेंस लागू करता है। यदि वंश वस्तु में एक ही प्रकार के कई शामिल हो सकते हैं, तो हम वस्तुओं के समावेश को वंशज वर्ग में शामिल करते हैं। हम एक ही वर्ग के व्यवहार को एक अलग वर्ग में बदलते हैं (जिसे मैं मिक्सिंग क्लास कहूंगा)। यह सब Alain Golub [2] द्वारा अच्छी तरह से चित्रित किया गया है, इसलिए मैंने उत्कृष्ट लिखित पाठ को नहीं दोहराया है। मैं सिर्फ इतना कहूंगा कि इस सरल महामारी नियम को याद किया जाना चाहिए और मशीन पर लागू किया जाना चाहिए।



एक बहुत कम विहित मुद्दा एक वर्ग के सदस्यों और सदस्य कार्यों के उपयोग के अधिकारों का वितरण है। बेशक, हर कोई एनकैप्सुलेशन के बारे में जानता है, हर कोई किताबें पढ़ता है। व्यवहार में यह सब क्या करना है?



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

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

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



आप शायद पूछते हैं: हो सकता है कि यह जटिल होने के लायक नहीं था, इसलिए कक्षाओं को अधिक खुला और अनुकूल क्यों नहीं बनाया जाए? "कोई रास्ता नहीं," मैं जवाब दूंगा, "और यहाँ क्यों है।"

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



मैंने क्या किया? मैंने बंकर वर्ग को जटिल कर दिया है, जो अब स्थानीय या दूरस्थ रूप से काम करता है। कुछ और कोड जोड़े जो GSM / ईथरनेट / RS-232 सेटिंग्स को उठाते हैं। और सबसे महत्वपूर्ण बात: बाकी सब कुछ वैसा ही बना हुआ है जैसा वह था। ठीक ट्यूनिंग नियंत्रण एल्गोरिदम के सभी महीने मेरे साथ बने हुए हैं! यही बात पत्रिका पर लागू होती है, और बाकी सब कुछ।

अगर मैं बंकर की आंतरिक रसोई से कम से कम कुछ बाहर लाया, तो मुझे यह कल्पना करने में भी डर नहीं है कि मुझे 250 केबी नियंत्रण कोड से कितना फिर से लिखना होगा।



एक बार फिर, मैं एक महत्वपूर्ण बिंदु दोहराऊंगा: C ++ प्रोग्राम की संरचना C से बिलकुल विपरीत है। वहां हमारे पास संरचनाएं और सामान्य चर थे। यहां हमारे पास ऑब्जेक्ट हैं जो ब्लैक बॉक्स हैं। प्रत्येक वस्तु अपने आप में एक रीपर, एक स्विस, एक पाइप पर एक दोस्त है।

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



मैं आपको याद दिलाता हूं कि ओपन क्लास मेंबर का थोड़ा ज्यादा वेटेड वर्जन है। इस दृष्टिकोण के साथ, हम रास्ते में नहीं हैं।



ऑब्जेक्ट के साथ बातचीत करने का सही तरीका उसे एक या किसी अन्य क्रिया को करने के लिए कहना है।

डेटा का अनुरोध करने के बजाय, हम ऑब्जेक्ट को अपने आप वांछित कार्रवाई करने के लिए कहते हैं। C ++ में बड़ी परियोजनाओं की स्थिरता के लिए यह एक आवश्यक शर्त है। कुछ मामलों में, कुछ कार्रवाई का कार्यान्वयन केवल एक वर्ग सदस्य के मूल्य को वापस करने के लिए है (बहुत अपवाद जो नियम की पुष्टि करता है)।



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



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



संदर्भ:

1. ब्योर्न स्ट्रैसेप। C ++ प्रोग्रामिंग भाषा।
2. Alain I. Golub "पर्याप्त लंबाई की एक रस्सी ... अपने आप को पैर में गोली मार।"

अगले भाग में: मैं नई / विलोपन समस्याओं को अलविदा कहता हूं , स्मार्ट पॉइंटर्स और कचरा संग्रहकर्ताओं की आवश्यकता से छुटकारा पाएं, उन्हें संसाधनों के साथ काम करने के सरल और अधिक प्राकृतिक तरीके से बदल दें।