RAII + C ++ वैरेडिक टेम्प्लेट = जीत

मैंने हाल ही में C ++ Variadic Templates को निकट से देखा और अप्रत्याशित रूप से नए RAII स्कोप्ड रिसोर्स मैनेजर का आविष्कार किया।
यह संक्षिप्त और प्रभावी रूप से निकला।

उदाहरण के लिए, C- शैली मेमोरी आवंटन के साथ:

//    . { ha::scoped_resource<void*, size_t> mem(::malloc, 1, ::free); ::memset(mem, 65, 1); } 

जब आप ब्लॉक से बाहर निकलते हैं, तो संसाधन स्वचालित रूप से मुक्त हो जाएगा।

या फिर इस तरह, आप फ़ाइल डिस्क्रिप्टर संसाधन के स्वामित्व को हड़प सकते हैं:

 //    . { ha::scoped_resource<int> fd( [&filename]() { return ::open(filename.c_str(), O_RDONLY); }, ::close); assert(fd != -1); std::vector<char> buff(1024); ssize_t rc = ::read(fd, &buff[0], 1024); } 

जब आप ब्लॉक से बाहर निकलते हैं, तो कॉल के बाद भी संसाधन स्वचालित रूप से जारी हो जाएगा, उदाहरण के लिए, throw std::exception() ।

या दूसरे उदाहरण को लंबोदर के उपयोग के बिना और भी स्पष्ट रूप से लिखा जा सकता है:

 { ha::scoped_resource<int, char*, int> fd(::open, filename.c_str(), O_RDONLY, ::close); if (fd == -1) throw std::runtime_error(std::string("open() failed: ") + ::strerror(errno)); std::vector<char> buff(1024); ssize_t rc = ::read(fd, &buff[0], 1024); } 

यही है, सामान्य मामले में, हमारे पास एक टेम्प्लेट क्लास है जो संसाधन प्रकार द्वारा त्वरित है, और इसका निर्माता दो std::functions : initializer_t finalizer_t स्वीकार करता है।

इनिशियलाइज़र और फ़ाइनलीज़र के बीच इनिशियलाइज़र के पैरामीटर हैं, जो टेम्प्लेट क्वालीफ़ायर का हिस्सा हैं।

विध्वंसक कैद किए गए संसाधन के लिए अंतिम रूप से कॉल करता है।

संसाधन तक कच्चे पहुंच के लिए, एक संसाधन प्रकार ऑपरेटर मौजूद है।

 { ha::scoped_resource <resource_t, param1_t, ...> resource (ititializer, param1, ..., finalizer); resource_t plain_resource = resource.operator resource_t(); } 

संसाधन रैपर के अन्य आरएआई कार्यान्वयन पर क्या लाभ है?

1. कंस्ट्रक्टर मापदंडों में कमी के दौरान इनिशलाइज़र को नहीं कहा जाता है, लेकिन कंस्ट्रक्टर में ही। यह, उदाहरण के लिए, एक "सामान्य" इनिशियलाइज़र ट्रांसफ़र को लागू करने की अनुमति देता है, जो operator resource_t() लिए पहली कॉल से पहले आलसी-शैली में एक संसाधन पर कब्जा करना संभव बनाता है। यह आपको नामांकित नामांकित बनाने की भी अनुमति देता है, जिससे उनका पुन: उपयोग किया जाता है।
2. आप प्रारंभिक रूप से किसी भी संख्या में मापदंडों को स्पष्ट रूप से पास कर सकते हैं। यहाँ, शायद, एक और दूसरा उपयोगी तंत्र है - std::initializer_list ।
3. यदि बिंदु 2. किसी कारण से लागू नहीं होता है, तो आप एक लैम्बडा को एक इनिशलाइज़र के रूप में पास कर सकते हैं, जो इनिशियलाइज़र के सभी मापदंडों को अपने आप में बंद कर देता है।
4. डिनायटिलाइज़र के पास एक एकल पैरामीटर है - संसाधन का प्रकार, लेकिन यदि आवश्यक हो तो यह एक लैम्ब्डा भी हो सकता है, अपने आप को डिनाइनिटाइजेशन के अतिरिक्त मापदंडों पर लॉक कर सकता है।
5. इसे std::shared_ptr(T* ptr, deleter d) से अधिक आसानी से लागू किया जा सकता है std::shared_ptr(T* ptr, deleter d) ।

नुकसान?

कभी-कभी पूर्ण संसाधन आवरण लिखने के लिए यह अभी भी अधिक कुशल है।

और उदाहरण चाहिए? मैंने उन्हें:

एक AVFormatContext संदर्भ बनाना:

 ha::scoped_resource<ffmpeg::AVFormatContext*> formatctx (ffmpeg::avformat_alloc_context, ffmpeg::avformat_free_context); 

यह निम्नलिखित का एक एनालॉग है:

 std::shared_ptr<ffmpeg::AVFormatContext> formatctx = std::shared_ptr<ffmpeg::AVFormatContext> (ffmpeg::avformat_alloc_context(), ffmpeg::avformat_free_context); 

या फिर, एक सम्मिश्र deinitializer यहाँ प्रयोग किया जाता है:

 ha::scoped_resource<ffmpeg::AVCodecContext*> codecctx( ffmpeg::avcodec_alloc_context, [](ffmpeg::AVCodecContext* c) { ffmpeg::avcodec_close(c), ffmpeg::av_free(c); }); 

और यह उदाहरण दिलचस्प है कि एक संसाधन पर कब्जा कर लिया गया है जिसे मुक्त करने की आवश्यकता नहीं है:

 ha::scoped_resource<ffmpeg::AVCodec*, ffmpeg::AVCodecID> codec( ffmpeg::avcodec_find_decoder, codecctx->codec_id, [](__attribute__((unused)) ffmpeg::AVCodec* c) { }); 

और अंत में सबसे आसान ऑनलाइनर:

 ha::scoped_resource<ffmpeg::AVFrame*> frame(ffmpeg::avcodec_alloc_frame, ffmpeg::av_free); 

जो निम्नलिखित के अनुरूप है:

 std::shared_ptr<ffmpeg::AVFrame> frame = std::shared_ptr<ffmpeg::AVFrame>(ffmpeg::avcodec_alloc_frame(), ffmpeg::av_free); 

लेकिन क्या यह वास्तव में नग्न सादे-सी संसाधनों के बारे में है? और मान्य C ++ वाले उदाहरण कहां हैं?

और यहाँ:

 ha::mutex mutex; ha::scoped_resource<ha::mutex*, ha::mutex*> scoped_lock( [](ha::mutex* m) -> ha::mutex* { return m->lock(), m; }, &mutex, [](ha::mutex* m) -> void { m->unlock(); } ); 

ठीक है, लेकिन कार्यान्वयन कहां है?

Scoped_resource वर्ग कार्यान्वयन इतना सरल और सुरुचिपूर्ण है कि इसने मुझे वाई-कॉम्बिनेटर के विचार को भी याद दिलाया।
यही है, यह आसानी से कुछ समान लागू करने के लिए संभव है, बस निर्माता scoped_resource::scoped_resource(initializer_t, finalizer_t); की घोषणा के साथ शुरू scoped_resource::scoped_resource(initializer_t, finalizer_t); और फिर मापदंडों के लिए वैरेडिक भाग का निर्माण करें।

ठीक है, लेकिन कार्यान्वयन वैसे भी कहाँ है, हुह?

 template <typename T, typename... A> class scoped_resource { public: typedef std::function<T (A...)> initializer_t; typedef std::function<void(T)> finalizer_t; typedef T resource_t; scoped_resource(initializer_t finit, A... args, finalizer_t final) : finit_(finit), final_(final), resource_(finit_(args...)) { }; ~scoped_resource() { final_(resource_); } template <typename Y> Y get() const { return static_cast<Y>(resource_); } T get() const { return resource_; } operator T() const { return get(); } // No copy, no move scoped_resource(const scoped_resource&) = delete; scoped_resource(scoped_resource&&) = delete; scoped_resource& operator=(const scoped_resource&) = delete; scoped_resource& operator=(scoped_resource&&) = delete; private: const initializer_t finit_; const finalizer_t final_; T resource_; }; 

कुछ इस तरह।