C ++ 11 में आरआईआई और प्रतिनिधि निर्माणकर्ता

इस पोस्ट में, हम C ++ 11 में एक दिलचस्प विशेषता के बारे में बात करेंगे, जिसे प्रतिनिधि निर्माणकर्ता कहा जाता है: यह दिलचस्प क्यों है, और इसे अधिक कुशल संसाधन प्रबंधन के लिए कैसे लागू किया जा सकता है, अर्थात्। मुहावरा RAII का कार्यान्वयन।

RAII के बारे में संक्षेप में (अच्छा, बहुत संक्षेप में)

जब हमें कुछ "नंगे" संसाधन के प्रबंधन को स्वचालित करने की आवश्यकता होती है, तो हम इसे एक अलग वर्ग में "लपेट" देते हैं। आइए इसे C मानक लाइब्रेरी से FILE जैसे संसाधन के उदाहरण के साथ प्रदर्शित करें:

#include <stdio.h> class File { public: File(char const * filename, char const * mode) : file_(fopen(filename, mode)) {} ~File() { fclose(file_); } File(File const &) = delete; File operator=(File const &) = delete; // file operations // ... private: FILE * file_; }; 

यहां हम कंस्ट्रक्टर में एक फ़ाइल संसाधन बनाते हैं और इसे विध्वंसक में जारी करते हैं। फ़ाइल संसाधन अब RAII मुहावरे के पूर्ण अनुपालन में प्रबंधित है।

RAII का थोड़ा और जटिल मामला

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

यह मामला इस तरह से लागू किया गया है:

 #include <stdio.h> class File { public: File(char const * filename, char const * mode) : file_(fopen(filename, mode)) { put_time_stamp(); } ~File() { fclose(file_); } File(File const &) = delete; File operator=(File const &) = delete; // file operations void put_time_stamp() { // throws on error // ... } private: FILE * file_; }; 

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

हम इस समस्या को कैसे हल करेंगे? एक कुंद माथे समाधान एक कोशिश / पकड़ ब्लॉक में put_time_stamp कॉल लपेटने के लिए है:

 class File { public: File(char const * filename, char const * mode) try : file_(fopen(filename, mode)) { put_time_stamp(); } catch (...) { destruct_obj(); } ~File() { destruct_obj(); } private: void destruct_obj() { fclose(file_); } FILE * file_; }; 

यह दृष्टिकोण काम करता है, लेकिन एक स्पष्ट कोशिश / कैच ब्लॉक की आवश्यकता के कारण यह थोड़ा बदसूरत है और ऑब्जेक्ट को स्पष्ट रूप से नष्ट करने के लिए एक अलग विधि है, ताकि कैच ब्लॉक और डिस्ट्रक्टर में समान कार्यक्षमता की नकल न करें।

यदि हम विशेष रूप से FILE, फ़ाइलहैंडल को संग्रहीत और हटाने के लिए एक अतिरिक्त वर्ग का परिचय देते हैं, तो हम इस समाधान को थोड़ा सुधार सकते हैं:

 class File { struct FileHandle { FileHandle(FILE * fh) : fh_(fh) {} ~FileHandle() { fclose(fh_); } FILE * fh_; } public: File(char const * filename, char const * mode) : file_(fopen(filename, mode)) { put_time_stamp(); } ~File() = default; private: FileHandle file_; }; 

जैसा कि आप देख सकते हैं, अब एक स्पष्ट कोशिश / कैच ब्लॉक की आवश्यकता नहीं है। फ़ाइल वर्ग के निर्माता से एक अपवाद को फेंक दिया जाता है और फ़ाइल संसाधन मुक्त हो जाता है, तो भी फ़ाइल_ ऑब्जेक्ट सही ढंग से नष्ट हो जाएगा। लेकिन इस समाधान में अभी भी एक खामी है, जिसमें एक अलग फाइलहैंडल वर्ग शामिल है, जो एक फाइल संसाधन के निर्माण और रिलीज को दो अलग-अलग वर्गों में विभाजित करता है: फ़ाइल वर्ग में फ़ाइल बनाया जाता है, और फाइलहैंडल वर्ग में मुक्त किया जाता है।

प्रतिनिधि रचनाकार

अब हम C ++ 11 से एक बहुत ही उपयोगी विशेषता को देखते हैं जिसे डेलिगेटिंग कंस्ट्रक्टर्स कहा जाता है, जो हमें फाइल क्लास के पिछले कोड को और बेहतर बनाने की अनुमति देगा। लेकिन पहले, आइए देखें कि ये प्रतिनिधि निर्माणकर्ता आम तौर पर कैसे काम करते हैं।

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

 class MyClass { public: MyClass(double param) { // construct object for double parameter } MyClass(int param) : MyClass(double(param)) // call ctor for double { // do some additional operations for int parameter // if necessary } }; 

डबल फ़िनिश निष्पादन के लिए कंस्ट्रक्टर के बाद, इंट के लिए कंस्ट्रक्टर ऑब्जेक्ट को फिर से बनाना और "री-कंस्ट्रक्शन" करना जारी रख सकता है। यह अपने आप में एक बहुत ही उपयोगी विशेषता है, जिसके बिना ऊपर दिए गए कोड में हमें संभवतः एक अतिरिक्त इनिट (डबल परम) फ़ंक्शन शुरू करना होगा ताकि टाइप डबल का ऑब्जेक्ट बनाने के लिए सामान्य कोड को एनकैप्सुलेट किया जा सके।

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

हम निम्न उदाहरण के साथ इस व्यवहार को प्रदर्शित करते हैं:

 class MyClass { public: MyClass(double) { cout << "ctor(double)\n"; } MyClass(int val) : MyClass(double(val)) { cout << "ctor(int)\n"; throw "oops!"; } ~MyClass() { cout << "dtor\n"; } }; int main() try { MyClass obj(10); cout << "obj created"; } catch (...) { cout << "exception\n"; } 

कंस्ट्रक्टर MyClass (int) एक अन्य कंस्ट्रक्टर MyClass (डबल) को कॉल करता है, जिसके बाद यह एक अपवाद फेंकता है। यह अपवाद कैच (...) में पकड़ा जाता है, और जब स्टैक समाप्त हो जाता है, तो ~ MyClass विध्वंसक कहा जाता है। इस कोड को निष्पादित करते समय, निम्नलिखित कंसोल पर प्रदर्शित किया जाएगा:

 ctor(double) ctor(int) dtor exception 

प्रतिनिधि रचनाकारों और आरएआई

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

 class File { File(FILE * file) : file_(file) {} public: File(char const * filename, char const * mode) : File(fopen(filename, mode)) { put_time_stamp(); } ~File() { fclose(file_); } void put_time_stamp() { ... } private: FILE * file_; }; 

और हम सभी की जरूरत है अपवादों के संबंध में बहुत सुंदर, सुरुचिपूर्ण और पूरी तरह से सुरक्षित (अपवाद सुरक्षित)। निष्कर्ष: एक समान तकनीक C ++ 11 से बिल्डरों के प्रतिनिधि का उपयोग करके नए कोड में RAII मुहावर के कार्यान्वयन की सुविधा प्रदान करेगी।