एक प्रोग्रामर की सेवा में स्मार्ट पॉइंटर्स और आरएआई

ऐतिहासिक रूप से, प्रबंधन चाहता है कि कार्य जल्दी से पूरा हो। इसके लिए, प्रोग्रामर कोड की सुंदरता और शुद्धता बनाए रखते हैं। यह पोस्ट C ++ 11 - स्मार्ट पॉइंटर्स में शायद ही कभी इस्तेमाल किए गए नवाचारों की याद दिलाता है जो आपको मुक्त संसाधनों के लिए एक फ़नकार निर्दिष्ट करने की अनुमति देता है।
उदाहरण के लिए, stdio.h से FILE फाइल स्ट्रीम लें, जो सादगी और गति के लिए पसंद की जाती है, अपवादों के साथ इसमें सुंदरता और मूल गारंटी जोड़ने का प्रयास करें:

unique_ptr<FILE, decltype(&fclose)> my_file(fopen("test.txt", "w"), &fclose); if(my_file) fwrite("test", 4, 1, my_file.get()); 

नतीजतन, कोड केवल एसटीएल पर निर्भर करता है और एक्सेस करने के लिए मामूली संशोधन की आवश्यकता होती है, जल्दी से लिखा जाता है, और आधुनिक दिखता है। इस तरह इसने RAII को अपने शुद्धतम रूप में बदल दिया।

यह कैसे काम करता है?

फोपेन फ़ंक्शन एक सूचक को टाइप FILE के ऑब्जेक्ट पर लौटाता है, जो my_file वैरिएबल में एक पॉइंटर के साथ fclose फ़ंक्शन में संग्रहीत किया जाता है। इस तरह, इस फ़ाइल स्ट्रीम का स्वामित्व स्थानीय चर में स्थानांतरित हो जाता है।

फेकलोज फ़ंक्शन को स्वचालित रूप से कब कहा जाएगा?

1. एक चर (उदाहरण के लिए, एक फ़ंक्शन से) के दायरे को छोड़ते समय।
2. यदि my_file बनाने के बाद कोई अपवाद होता है।
3. असाइनमेंट फ़ंक्शन को कॉल करते समय ऑब्जेक्ट my_file पर।
4. My_file.reset पर कॉल करते समय ()।

ओवरहेड क्या है?

1. प्रोग्रामर को फ़ाइल के निर्माण को जटिल बनाने की जरूरत है, फेक कॉल को हटाएं और अनूठे_ptr <...> :: get () कॉल को सभी फ़ाइल एक्सेस में जोड़ें।
2. सबसे खराब स्थिति में, कंपाइलर को फाइल डिलीशन फ़ंक्शन के लिए एक पॉइंटर रखने के लिए मेमोरी सेल की आवश्यकता होगी। पूरी तरह से, यह सिर्फ आपके लिए सही जगह पर fclose कॉल करेगा, पूरी तरह से my_file ऑब्जेक्ट को ऑप्टिमाइज़ करता है।

इस दृष्टिकोण के क्या फायदे हैं?

1. किसी भी स्मार्ट पॉइंटर के साथ, आप स्पष्ट रूप से निर्दिष्ट करते हैं कि आप ऑब्जेक्ट के मालिक कैसे हैं। इस स्थिति में, यह इंगित किया जाता है कि ऑब्जेक्ट साझा नहीं किया गया है (unique_ptr)।
2. आप इस प्रकार की घोषणा करके अनावश्यक कॉपी-पेस्ट से छुटकारा पा सकते हैं:

    typedef unique_ptr<FILE, decltype(&fclose)> MyFileType; 

3. यदि आप बहुत सारी फ़ाइलों का उपयोग करते हैं, तो यह एक छोटा आवरण लिखने के लिए समझ में आता है
   

    MyFileType MakeFile(const char* filename, const char* mode) { return unique_ptr<FILE, decltype(&fclose)>(fopen(filename, mode), &fclose); } 

   ... और इसे इस तरह उपयोग करें:
   

    auto my_file = MakeFile("test.txt", "w"); 

4. आपको विध्वंसक में अतिरिक्त कोड लिखने से छुटकारा पाने की अनुमति देता है। बहुत ज्यादा क्यों? आपने पहले ही संकलक को संकेत दिया है कि आप इस संसाधन का प्रबंधन कैसे करना चाहते हैं, और अब यह उसका काम है।
5. आप मानक STL कंटेनरों में MyFileType प्रकार की वस्तुओं का उपयोग कर सकते हैं:
   

    vector<MyFileType> my_files; my_files.push_back(MakeFile("test.txt", "w")); 

   ... और वस्तुओं के जीवनकाल को नियंत्रित करने में अपना समय बर्बाद मत करो। C ++ 11 में, वेक्टर <MyFileType> को फ़ंक्शन से सुरक्षित रूप से वापस किया जा सकता है।

सी रनटाइम लाइब्रेरी के कुछ और विचार इस प्रकार हैं:

जो लोग विंडोज के लिए अनुकूलन पर हैरान या उत्सुक हैं, वे जानते हैं कि संरेखित डेटा तक पहुंच तेज है। तो आप Microsoft Visual C रनटाइम लाइब्रेरी का उपयोग करके 16 बाइट्स से जुड़ी मेमोरी के लिए एक पॉइंटर बना सकते हैं:

 unique_ptr<char[], decltype(&::_aligned_free)> my_buffer((char*)(_aligned_malloc(512, 16)), &_aligned_free); my_buffer[0] = 'x'; //   

एक बार टेम्पलेट लिखने के बाद:

 template<typename T> unique_ptr<T[], decltype(&::_aligned_free)> MakeAlignedBuffer(size_t element_count, size_t alignment = alignment_of<T>::value) { return unique_ptr<T[], decltype(&::_aligned_free)> (reinterpret_cast<T*>(_aligned_malloc(element_count*sizeof(T), alignment)), &_aligned_free); } 

आप अलग-अलग फ़ंक्शन के साथ मेमोरी को आवंटित करने और हटाने की त्रुटियों के बारे में भूल सकते हैं (एक मॉड्यूल में नए [] के माध्यम से बनाया गया, दूसरे में हटाए गए के माध्यम से हटा दिया गया)।

लेकिन क्या होगा अगर कई ऑब्जेक्ट एक विशिष्ट WinAPI संसाधन के मालिक हों?

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

 auto my_module = shared_ptr<HMODULE>(new HMODULE(LoadLibrary(_T("my_library.dll"))), [](HMODULE* instance){ FreeLibrary(*instance); //         }); 

अगला, हम वस्तुओं को my_module वितरित करते हैं ...

 module_owner1.set_module(my_module); module_owner2.set_module(my_module); //     vector   

वस्तु में हम आवश्यक कार्यों का उपयोग करते हैं ...

 if(my_module && *my_module) { auto func1 = GetProcAddress(*my_module, "MyFunc"); } 

जब हम फ़ंक्शन का उपयोग करना बंद कर देते हैं और ऑब्जेक्ट के लिए संदर्भ काउंटर शून्य हो जाता है, तो फ्रीलांस फ़ंक्शन को कॉल किया जाएगा और ऑब्जेक्ट हटा दिया जाएगा।

अनूठे_प्ट्र में लैम्ब्डा फ़ंक्शन का उपयोग कैसे करें?

आपको फ़ंक्शन टेम्पलेट का उपयोग इस तरह करना होगा:

 auto my_instance = std::unique_ptr<HMODULE, function<void(HMODULE*)>> (new HMODULE(LoadLibrary(_T("my_library.dll"))), [](HMODULE* instance){ FreeLibrary(*instance); }); 

निष्कर्ष

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