🎣 🙄 📣 C ++ में प्रोग्रामिंग करते समय और उससे कैसे निपटें, कॉपी-पेस्ट तकनीक का उपयोग करने का परिणाम 🐒 👏🏼 ✝️

मैं एक PVS-Studio विश्लेषक बना रहा हूँ जो C / C ++ / C ++ 0x अनुप्रयोगों के स्रोत कोड में त्रुटियों का पता लगाता है। इस संबंध में, मुझे विभिन्न अनुप्रयोगों के लिए बड़ी मात्रा में स्रोत कोड के माध्यम से ब्राउज़ करना होगा जहां पीवीएस-स्टूडियो का उपयोग करके संदिग्ध कोड टुकड़े का पता लगाया गया था। मैंने पर्याप्त उदाहरण संचित कर लिए हैं जिसमें यह स्पष्ट रूप से दिखाई देता है जब एक कोड की एक प्रति और उसके संशोधन की वजह से एक त्रुटि पैदा हुई थी। बेशक, यह एक नया विचार नहीं है कि प्रोग्रामिंग खराब होने पर कॉपी-पेस्ट का उपयोग करना। हालाँकि, आइए, अनुशंसा करें कि "कोड को कॉपी न करें" को बंद न करें और इस विषय पर अधिक सावधानी से आएं।

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

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

आइए अब हम उस क्षण पर ध्यान केंद्रित करें, जो आमतौर पर उच्च गुणवत्ता वाले कोड लिखने पर पुस्तकों और लेखों में चुप है। वास्तव में, कॉपी-पेस्ट के बिना, प्रोग्रामिंग संभव नहीं है। यह सोवियत संघ में सेक्स की तरह है। वह नहीं है, लेकिन हर कोई इसे कर रहा है।

जब हम कुछ इस तरह लिखने की जरूरत है हम सभी छोटे टुकड़ों की नकल करते हैं:

  GetMenu () -> CheckMenuItem (IDC_ LINES_X, MF_BYCOMMAND | nState);
 GetMenu () -> CheckMenuItem (IDC_ LINES_Y, MF_BYCOMMAND | nState);

अपने आप को ईमानदारी से स्वीकार करें कि हम एक लाइन टाइप करने के लिए बहुत आलसी हैं जो केवल 'X' के बजाय उस वर्ण में भिन्न होता है जिसे हमें 'Y' अक्षर लिखने की आवश्यकता होगी। और यह सही और तार्किक है। कॉपी करना और संपादित करना दूसरे स्टॉक को फिर से लिखने से भी तेज होगा, यहां तक कि विशेष उपकरण जैसे विजुअल असिस्ट और इंटेलीजेंस के उपयोग को भी ध्यान में रखना।

हालाँकि, कोड डुप्लीकेशन के बारे में बात करने का कोई मतलब नहीं है। यहाँ लिखना आसान नहीं है। किसी भी कार्यक्रम को ले कर बड़ी संख्या में ऐसे उदाहरण दिए जा सकते हैं। मुझे यह पसंद नहीं है कि यहाँ उदाहरण GUI की चिंता करता है, और अन्य कार्यों में हम एक समान पाएंगे:

  int texlump1 = Wads.CheckNumForName ("TEXTURE1", ns_global, wadnum);
 int texlump2 = Wads.CheckNumForName ("TEXTURE2", ns_global, wadnum);

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

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

बेहतर तरीके से यह बताने के लिए कि किस तरह की त्रुटियां हैं, आइए खुले स्रोत परियोजनाओं से लिए गए कुछ कोड उदाहरणों पर ध्यान दें। एक विज्ञापन के रूप में: मेरे द्वारा सूचीबद्ध त्रुटियों को सामान्य-उद्देश्य विश्लेषक का उपयोग करके खोजा गया था, जो पीवीएस-स्टूडियो [ 2 ] का हिस्सा है।

कोड एक ध्वनि रिकॉर्डिंग और संपादन कार्यक्रम - ऑडेसिटी से लिया गया है।

 sampleCount VoiceKey :: OnBackward (...) {... int atrend = sgn (बफर [नमूनेleft - 2] -buffer [नमूनेleft - 1]);  int ztrend = sgn (बफ़र [नमूनेलेफ्ट - WindowSizeInt-2] - बफर [नमूने-विंडो - WindowSizeInt-2]);  ...}

प्रोग्रामर ने साहसपूर्वक और सही ढंग से चर के आरंभ को 'atrend' लिखा। मैंने चर 'ज़ट्रेंड' के इनिशियलाइज़ेशन को लिखना शुरू किया। लिखा था "sgn (बफर [नमूनेलेफ्ट - WindowSizeInt-2]।" फिर उसने कटा हुआ और स्ट्रिंग का एक टुकड़ा कॉपी किया। मैं इसे संपादित करना भूल गया। नतीजतन, फ़ंक्शन 'sgn' को एक तर्क के रूप में 0 मिलेगा।

आगे भी परिदृश्य इसी तरह का होगा। प्रोग्रामर क्रिस्टल स्पेस 3 डी एसडीके में एक लंबी शर्त लिखता है:

  इनलाइन_ बूल शामिल (const LSS & lss)
 {
   // हम LSS दो की जाँच करें 
   // स्वीप की शुरुआत और अंत में गोले
   वापसी
     इसमें शामिल हैं (क्षेत्र (lss.mP0, lss.mRadius)) && 
     इसमें शामिल हैं (स्फीयर (lss.mP0, lss.mRadius));
 }

यहाँ मैं सिर्फ "Contains (Sphere (lss.mP0, lss.mRadius))" को कॉपी करना चाहता हूं और 'mP0' नाम को 'mP1' से बदल दूंगा। लेकिन गलती से ऐसा करना आसान है।

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

  शून्य COX3DTabViewContainer :: OnNcPaint () 
 {
   ...
   अगर (rectClient.top <rectClient.bottom &&
      rectClient.top <rectClient.bottom)
   {
     dc.ExcludeClipRect (rectClient);
   }
   ...
 }

यह कोड कक्षाओं के प्रसिद्ध सेट अल्टीमेट टूलबॉक्स से लिया गया है । आम तौर पर नियंत्रण खींचा जाएगा या नहीं, यह उसके स्थान पर निर्भर करेगा।

और eLynx इमेज प्रोसेसिंग एसडीके में, एक पूरी लाइन को कॉपी किया गया और एक टाइपो को दोहराया गया।

  शून्य uteTestRunner :: StressBayer (uint32 iFlags)
 {
   ...
   स्थिर EPixelFormat ms_pfList [] = 
     {PF_Lub, PF_Lus, PF_Li, PF_Lf, PF_Ld};
   const int fsize = sizeof (ms_pfList) / sizeof (ms_pfList);

   स्थिर EBayerMatrix ms_bmList [] = 
     {BM_GRBG, BM_GBRG, BM_RGGB, BM_BGGR, BM_None};
   const int bsize = sizeof (ms_bmList) / sizeof (ms_bmList);
   ...
 }

पॉइंटर के भूल गए डेरेफेरिंग के कारण, चर 'fsize' 1. है और फिर इस कोड को 'bsize' को इनिशियलाइज़ करने के लिए अनुकूलित किया गया था। मेरा मानना है कि यदि आप कोड की प्रतिलिपि नहीं बनाते हैं तो दो बार इस तरह की गलती करना संभव है।

EIB सुइट प्रोजेक्ट में, "if (_relativeTime <= 143)" लाइन को कॉपी और एडिट किया गया था। लेकिन केवल अंतिम स्थिति में वे इसे बदलना भूल गए:

  string TimePeriod :: toString () const
 {
   ...
   अगर (_relativeTime <= 143)
     ओएस << ((int) _relativeTime + 1) * 5 << _ ("मिनट");
   और यदि (_relativeTime <= 167)
     ओएस << 12 * 60 + ((इंट) _relativeTime - 143) * 30 << _ ("मिनट");
   और यदि (_relativeTime <= 196)
     ओएस << (int) _relativeTime - 166 << _ ("दिन");
   और यदि (_relativeTime <= 143)
     ओएस << (int) _relativeTime - 192 << _ ("सप्ताह");
   ...
 }

तो कोड "os << (int) _relativeTime - 192 << _ (" सप्ताह ") है;" कभी नियंत्रण नहीं मिलेगा।

यहां तक कि इंटेल के प्रोग्रामर भी केवल प्रोग्रामर हैं, डिमिगोड नहीं। टिकरटेप परियोजना में असफल नकल:

  शून्य DXUTUpdateD3D10DeviceStats (...)
 {
   ...
   अगर (DeviceType == D3D10_DRIVER_TYPE_SOFTWARE)
     wcscpy_s (pstrDeviceStats, 256, L "WARP");
   अगर (DeviceType == D3D10_DRIVER_TYPE_HARDWARE)
     wcscpy_s (pstrDeviceStats, 256, L "हार्डवेयर");
   अगर (DeviceType == D3D10_DRIVER_TYPE_SOFTWARE)
     wcscpy_s (pstrDeviceStats, 256, L "सॉफ़्टवेयर");
   ...
 }

"DeviceType == D3D10_DRIVER_TYPE_SOFTWARE" की स्थिति दो बार दोहराई जाती है।

सामान्य तौर पर, सशर्त बयानों के मोटेपन में, त्रुटि को देखना बहुत आसान है। मल्टी-थ्रेडेड डायनेमिक क्यू के कार्यान्वयन में, चाहे जो भी हो ईफिक्सड () फ़ंक्शन रिटर्न, हम वही करेंगे:

  BOOL CGridCellBase :: PrintCell (...)
 {
   ...
   अगर (IsFixed ())
     crFG = (GetBackClr ()! = CLR_DEFAULT)?
       GetTextClr (): pDefaultCell-> GetTextClr ();
   अन्यथा
     crFG = (GetBackClr ()! = CLR_DEFAULT)?
       GetTextClr (): pDefaultCell-> GetTextClr ();
   ...
 }

वैसे, कोड की नकल करना आसान और सुखद है! एक अतिरिक्त लाइन लिखने का मन न करें। :)

  शून्य RB_CalcColorFromOneMinusEntity (अहस्ताक्षरित चार * dstClors) {
   ...
   अहस्ताक्षरित चार invModulate [3];
   ...
   invModulate [0] = 255 - backEnd.currentEntity-> e.shaderRGBA [0];
   invModulate [1] = २५५ - backEnd.currentEntity-> e.shaderRGBA [१];
   invModulate [2] = 255 - backEnd.currentEntity-> e.shaderRGBA [2];
   invModulate [3] = 255 - backEnd.currentEntity-> e.shaderRGBA [3];
   ...
 }

इससे कोई फर्क नहीं पड़ता कि सरणी 'invModulate' में केवल तीन तत्व शामिल हैं। कोड को प्रसिद्ध वोल्फेंस्टीन 3 डी गेम की परियोजना से लिया गया है।

और अंत में, उदाहरण अधिक जटिल है। कोड एक बहुत उपयोगी उपकरण नोटपैड ++ से लिया गया है।

  शून्य KeyScriptStyleDialog :: updateDlg () 
 {
   ...
   शैली और w1Style =
     _pUserLang -> _ styleArray.getStyler (STYLE_WORD1_INDEX);
   styleUpdate (w1Style, _pFgColour [0], _pBgColour [0],
     IDC_KEYWORD1_FONT_COMBO, IDC_KEYWORD1_FONTSIZE.COMBO,
     IDC_KEYWORD1_BOLD_CHECK, IDC_KEYWORD1_ITALIC_CHECK,
     IDC_KEYWORD1_UNDERLINE_CHECK);

   शैली और w2Style =
     _pUserLang -> _ styleArray.getStyler (STYLE_WORD2_INDEX);
   styleUpdate (w2Style, _pFgColour [1], _pBgColour [1],)
     IDC_KEYWORD2_FONT_COMBO, IDC_KEYWORD2_FONTSIZE.COMBO,
     IDC_KEYWORD2_BOLD_CHECK, IDC_KEYWORD2_ITALIC_CHECK,
     IDC_KEYWORD2_UNDERLINE_CHECK);

   शैली और w3Style =
     _pUserLang -> _ styleArray.getStyler (STYLE_WORD3_INDEX);
   styleUpdate (w3Style, _pFgColour [2], _pBgColour [2],
     IDC_KEYWORD3_FONT_COMBO, IDC_KEYWORD3_FONTSIZE.COMBO,
     IDC_KEYWORD3_BOLD_CHECK, IDC_KEYWORD3_BOLD_CHECK,
     IDC_KEYWORD3_UNDERLINE_CHECK);

   शैली और w4Style =
     _pUserLang -> _ styleArray.getStyler (STYLE_WORD4_INDEX);
   styleUpdate (w4Style, _pFgColour [3], _pBgColour [3],
     IDC_KEYWORD4_FONT_COMBO, IDC_KEYWORD4_FONTSIZE.COMBO,
     IDC_KEYWORD4_BOLD_CHECK, IDC_KEYWORD4_ITALIC_CHECK,
     IDC_KEYWORD4_UNDERLINE_CHECK);
   ...
 }

आपको यहां पर गलती पर विचार करने के लिए अपनी आँखें तोड़नी होंगी। इसलिए, मैं स्पष्टता के लिए कोड को छोटा करूंगा:

  स्टाइलअपडेट (...
   IDC_KEYWORD1_BOLD_CHECK, IDC_KEYWORD1_ITALIC_CHECK,
   ...);
 स्टाइलअपडेट (...
   IDC_KEYWORD2_BOLD_CHECK, IDC_KEYWORD2_ITALIC_CHECK,
   ...);
 स्टाइलअपडेट (...
   IDC_KEYWORD3_BOLD_CHECK, IDC_KEYWORD3_BOLD_CHECK,
   ...);
 स्टाइलअपडेट (...
   IDC_KEYWORD4_BOLD_CHECK, IDC_KEYWORD4_ITALIC_CHECK,
   ...);

डेवलपर का हाथ लड़खड़ा गया और उसने गलत संसाधन नाम की नकल की।

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

ईमानदार होने के लिए, मुझे पूर्ण उत्तर नहीं पता है। कम से कम इसी तरह की स्थितियों के बारे में किताबों में मैंने नहीं पढ़ा। लेकिन व्यवहार में, मैं अक्सर कार्यक्रमों में छोटे कॉपी-पेस्ट के परिणामों से मिलता था। अपने में सम्‍मिलित करना। प्रश्न का उत्तर देते हुए, आपको सुधार करना होगा।

हम निम्नलिखित स्थिति से आगे बढ़ेंगे:

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

इस निष्कर्ष से:

ऐसी त्रुटियों को रोकने के लिए पूरी तरह से असंभव है, लेकिन आप उनके निर्माण की संभावना को कम करने की कोशिश कर सकते हैं।

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

दूसरा तरीका, जो कुछ मामलों में त्रुटियों की संख्या को कम करने में मदद करेगा, अपने आप को अनुशासित करना और कॉपी किए गए कोड को एक विशेष तरीके से प्रारूपित करना है। मैं एक उदाहरण के साथ समझाऊंगा।

  int ztrend = sgn (
     बफर [नमूने-खिड़की - WindowSizeInt-2] -buffer [नमूने-खिड़की - WindowSizeInt-2]);

इसलिए, यदि कोड ऐसा दिखता है, तो त्रुटि को नोटिस करना बहुत कठिन है:

  int ztrend = sgn (
     बफर [नमूने-खिड़की - WindowSizeInt-2] -
     बफर [नमूने-खिड़की - WindowSizeInt-2]);

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

दुर्भाग्य से, मैं कम से कम किसी भी तरह से कॉपी-पेस्ट से जुड़ी त्रुटियों की संख्या को कम करने के अन्य तरीकों को नहीं जानता। आप अभी भी डुप्लिकेट और समान कोड के लिए खोज टूल का उपयोग कर सकते हैं, लेकिन इसे स्टेटिक एनालिसिस का उपयोग करने की सलाह के लिए जिम्मेदार ठहराया जा सकता है।

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

ग्रंथ सूची

स्टीव मैककोनेल, "कोड कम्प्लीट, 2 डी एडिशन" माइक्रोसॉफ्ट प्रेस, पेपरबैक, 2 डी संस्करण, जून 2004 को प्रकाशित, 914 पृष्ठ, आईएसबीएन: 0-7356-1967-0। (भाग २४.३। रिफ्लेक्टर के कारण)
प्रस्तुति "पीवीएस-स्टूडियो, आधुनिक संसाधन-गहन अनुप्रयोगों के विकास के लिए एक व्यापक समाधान।" http://www.viva64.com/ru/pvs-studio-presentation/

C ++ में प्रोग्रामिंग करते समय और उससे कैसे निपटें, कॉपी-पेस्ट तकनीक का उपयोग करने का परिणाम

ग्रंथ सूची

More articles: