कांटा न जानने से, पानी में नहीं उतरता। एक भाग

मैं इस बारे में कुछ छोटे नोट्स लिखना चाहता था कि सी / सी ++ प्रोग्रामर बिना किसी संदेह के आग से कैसे खेलते हैं। पहला नोट कंस्ट्रक्टर को स्पष्ट रूप से कॉल करने की कोशिश के बारे में होगा।

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

उदाहरण के लिए, प्रोग्रामर वर्ग में एकल इनिशियलाइज़ेशन फंक्शन बनाने के लिए बहुत आलसी होते हैं और फिर उसे विभिन्न कंस्ट्रक्टरों से बुलाते हैं। प्रोग्रामर सोचता है: “मुझे एक अतिरिक्त कार्य की आवश्यकता क्यों है? मैं एक निर्माता को दूसरे से बुलाना चाहता हूं। " दुर्भाग्य से, यहां तक ​​कि यह सरल कार्य भी प्रोग्रामर हमेशा हल करने में सक्षम नहीं है। इस तरह के असफल प्रयासों की पहचान करने के लिए, मैं अभी पीवीएस-स्टूडियो में एक नया नियम लागू कर रहा हूं। यहाँ उस कोड का एक उदाहरण है जो मुझे eMule प्रोजेक्ट में मिला है:

  वर्ग CSlideBarGroup
 {
 सार्वजनिक:
   CSlideBarGroup (CString strName,
     INT iIconIndex, CListBoxST * pListBox);
   CSlideBarGroup (CSlideBarGroup & Group);
   ...
 }

 CSlideBarGroup :: CSlideBarGroup (CSlideBarGroup और समूह)
 {
   CSlideBarGroup (
     Group.GetName (), Group.GetIconIndex (), Group.GetListBox ());
 } 

अंतिम रचनाकार के कार्यान्वयन पर ध्यान से विचार करें। प्रोग्रामर ने फैसला किया कि कोड

  CSlideBarGroup (
   Group.GetName (), Group.GetIconIndex (), Group.GetListBox ()); 

बस एक और निर्माता को बुलाता है। कुछ भी नहीं। यहाँ CSlideBarGroup प्रकार का एक नया अनाम ऑब्जेक्ट बनाया गया है और तुरंत नष्ट कर दिया गया है।

यह पता चला है कि प्रोग्रामर ने वास्तव में एक अन्य निर्माता कहा था। लेकिन वह बिल्कुल भी नहीं था कि वह क्या करना चाहता था। वर्ग क्षेत्र असिंचित रहेंगे।

ऐसी गलतियाँ केवल आधी परेशानी हैं। कुछ लोग जानते हैं कि वास्तव में किसी अन्य निर्माता को कैसे कॉल किया जाए। और कारण। यह बेहतर होगा यदि वे नहीं जानते कि यह कैसे करना है। :)

उदाहरण के लिए, उपरोक्त कोड इस तरह से फिर से लिखा जा सकता है:

  CSlideBarGroup :: CSlideBarGroup (CSlideBarGroup और समूह)
 {
   यह-> CSlideBarGroup :: CSlideBarGroup (
     Group.GetName (), Group.GetIconIndex (), Group.GetListBox ());
 } 

या तो:

  CSlideBarGroup :: CSlideBarGroup (CSlideBarGroup और समूह)
 {
   नया (यह) CSlideBarGroup (
     Group.GetName (), Group.GetIconIndex (),
     Group.GetListBox ());
 } 

अब डेटा को इनिशियलाइज़ करने के लिए वास्तव में एक कंस्ट्रक्टर दूसरे कंस्ट्रक्टर को कहता है।

यदि आप एक प्रोग्रामर देखते हैं जो ऐसा करता है, तो उसके सामने एक शेल्फ दें और एक मुझे व्यक्तिगत रूप से।

उपरोक्त उदाहरण बहुत खतरनाक कोड हैं, और आपको यह समझने की आवश्यकता है कि वे कैसे काम करते हैं!

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

  कक्षा SomeClass
 {
   int x, y;
 सार्वजनिक:
   SomeClass () {new (यह) SomeClass (0,0);  }
   SomeClass (int xx, int yy): x (xx), y (yy) {}
 }; 

यह कोड सही तरीके से काम करेगा। कोड सुरक्षित है और काम करता है क्योंकि वर्ग में सरल डेटा प्रकार हैं और अन्य वर्गों से विरासत में नहीं मिला है। इस मामले में, कंस्ट्रक्टर को दोहरी कॉल से कुछ भी खतरा नहीं है।

एक अन्य कोड पर विचार करें जहां एक स्पष्ट कंस्ट्रक्टर कॉल में त्रुटि होती है (उदाहरण StackOverflow वेबसाइट पर चर्चा से लिया गया है):

  वर्ग का आधार 
 { 
 सार्वजनिक: 
  चार * पीटीआर; 
  std :: वेक्टर वेक्ट; 
  आधार () {पीटीआर = नया चार [1000];  } 
  ~ आधार () {हटाना [] पीटीआर;  } 
 }; 
 
 वर्ग व्युत्पन्न: आधार 
 { 
   व्युत्पन्न (फू फू) {} 
   व्युत्पन्न (बार बार) { 
      नया (यह) व्युत्पन्न (bar.foo); 
   } 
 } 

जब हम कंस्ट्रक्टर को "नया (यह) व्युत्पन्न (बार.फू)" कहते हैं, तो बेस ऑब्जेक्ट पहले से ही बनाया जाता है और खेतों को आरंभीकृत किया जाता है। कंस्ट्रक्टर को याद करने से दोहरी शुरुआत हो जाएगी। 'Ptr' में नई आवंटित मेमोरी के लिए एक पॉइंटर लिखें। नतीजतन, हमें एक मेमोरी लीक मिलती है। यह भविष्यवाणी करना मुश्किल है कि प्रकार एसटीडी :: वेक्टर के ऑब्जेक्ट का दोहरा इनिशियलाइज़ेशन क्या होगा। एक बात साफ है। यह कोड मान्य नहीं है।

निष्कर्ष

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

  यहां बताया गया है कि सही कोड कैसा दिखना चाहिए:
 वर्ग CSlideBarGroup
 {
   शून्य इनिट (CString strName, INT iIconIndex,
             CListBoxST * pListBox);
 सार्वजनिक:
   CSlideBarGroup (CString strName, INT iIconIndex,
                  CListBoxST * pListBox)
   {
     Init (strName, iIconIndex, pListBox);
   }
   CSlideBarGroup (CSlideBarGroup और समूह)
   {
     Init (Group.GetName) (), Group.GetIconIndex (),
          Group.GetListBox ());
   }
   ...
 };