C ++ / CLI में, तथाकथित डिस्क्रिप्टर कक्षाएं अक्सर उपयोग की जाती हैं - प्रबंधित कक्षाएं जो एक सदस्य के रूप में मूल वर्ग के लिए एक सूचक होती हैं। लेख प्रबंधित टेम्प्लेट के उपयोग के आधार पर संबंधित मूल वस्तु के जीवनकाल के प्रबंधन के लिए एक सुविधाजनक और कॉम्पैक्ट योजना पर चर्चा करता है। अंतिम रूप देने के जटिल मामलों पर विचार किया जाता है।

सामग्री की तालिका

परिचय
1. C ++ / CLI में बेसिक डिस्पोजल पैटर्न
1.1। विध्वंसक और फाइनल की परिभाषा
1.2। स्टैक शब्दार्थ का उपयोग करना
2. प्रबंधित टेम्पलेट्स
2.1। स्मार्ट पॉइंटर्स
2.2। उदाहरण का उपयोग करें
2.3। अधिक जटिल अंतिम विकल्प
2.3.1। फाइनल लॉक
2.3.2। सेफहैंडल का उपयोग करना
संदर्भ

परिचय

C ++ / CLI - .NET फ्रेमवर्क की भाषाओं में से एक - का उपयोग शायद ही कभी बड़ी स्वतंत्र परियोजनाओं को विकसित करने के लिए किया जाता है। इसका मुख्य उद्देश्य देशी (अप्रबंधित) कोड के साथ .NET इंटरैक्शन के लिए असेंबली बनाना है। तदनुसार, वर्णक वर्ग नामक कक्षाएं व्यापक रूप से उपयोग की जाती हैं, प्रबंधित कक्षाएं जिनका सदस्य के रूप में मूल वर्ग के लिए एक सूचक होता है। आमतौर पर, इस तरह के एक डिस्क्रिप्टर क्लास का मूल निवासी ऑब्जेक्ट होता है, अर्थात, उसे उचित समय पर हटाना चाहिए। इस तरह के एक वर्ग को छूट देना काफी स्वाभाविक है, यानी System::IDisposable लागू करना System::IDisposable । .NET में इस इंटरफ़ेस के कार्यान्वयन को एक विशेष पैटर्न का पालन करना चाहिए जिसे बेसिक डिस्पोज़ [Cwalina] कहा जाता है। सी ++ / सीएलआई की एक उल्लेखनीय विशेषता यह है कि कंपाइलर इस टेम्पलेट को लागू करने के लगभग सभी नियमित काम करता है, जबकि सी # में लगभग सब कुछ हाथ से करना पड़ता है।

1. C ++ / CLI में बेसिक डिस्पोजल पैटर्न

इस टेम्पलेट को लागू करने के दो मुख्य तरीके हैं।

1.1। विध्वंसक और फाइनल की परिभाषा

इस मामले में, विध्वंसक और अंतिम रूप से प्रबंधित वर्ग में परिभाषित किया जाना चाहिए, कंपाइलर बाकी काम करेगा।

 public ref class X {    ~X() {/* ... */} //     !X() {/* ... */} //  // ... }; 

विशेष रूप से, संकलक निम्नलिखित करता है:

1. X कक्षा के लिए X System::IDisposable लागू करता System::IDisposable ।
2. X::Dispose() विध्वंसक को कॉल प्रदान करता है, बेस क्लास (यदि कोई हो) के GC::SupressFinalize() को कॉल करता है, और GC::SupressFinalize() को कॉल करता है GC::SupressFinalize() ।
3. ओवरराइड्स System::Object::Finalize() , जहां यह आधार कक्षाओं के फाइनल और फाइनलर्स (यदि कोई हो) को एक कॉल प्रदान करता है।

आप System::IDisposable से विरासत को स्पष्ट रूप से निर्दिष्ट कर सकते हैं, लेकिन आप X::Dispose() स्वयं परिभाषित नहीं कर सकते।

1.2। स्टैक शब्दार्थ का उपयोग करना

बेसिक डिस्पोज़ पैटर्न को कंपाइलर द्वारा भी लागू किया जाता है यदि वर्ग में मुक्त प्रकार का सदस्य होता है और स्टैक शब्दार्थ का उपयोग करके इसे घोषित किया जाता है। इसका मतलब यह है कि कैप के बिना टाइप नाम (' ^ ') का उपयोग घोषणा के लिए किया जाता है, और आरंभीकरण निर्माणकर्ता आरंभीकरण सूची में होता है, न कि gcnew साथ। स्टैक के शब्दार्थ [होगेंसन] में वर्णित हैं।

यहाँ एक उदाहरण है:

 public ref class R : System::IDisposable { public:    R(/*  */); //  // ... }; public ref class X {    R m_R; //   R^ m_R public:    X(/*  */) //         : m_R(/*  */) //   m_R = gcnew R(/*  */)    {/* ... */} // ... }; 

इस मामले में संकलक निम्नलिखित करता है:

1. X कक्षा के लिए X System::IDisposable लागू करता System::IDisposable ।
2. X::Dispose() m_R लिए R::Dispose() को कॉल प्रदान करता है।

अंतिम रूप निर्धारण इसी वर्ग R कार्यक्षमता द्वारा निर्धारित किया जाता है। पिछले मामले की तरह, System::IDisposable से विरासत System::IDisposable को स्पष्ट रूप से निर्दिष्ट किया जा सकता है, लेकिन आप X::Dispose() स्वयं परिभाषित नहीं कर सकते। स्वाभाविक रूप से, वर्ग में स्टैक के शब्दार्थों का उपयोग करके घोषित अन्य सदस्य हो सकते हैं, और उनके लिए उनके Dispose() कॉल भी प्रदान की जाती है।

2. प्रबंधित टेम्पलेट्स

और अंत में, C ++ / CLI की एक और बड़ी विशेषता यह है कि जितना संभव हो सके वर्णनकर्ता वर्गों के निर्माण को सरल बनाना संभव है। हम प्रबंधित टेम्पलेट्स के बारे में बात कर रहे हैं। ये क्लासिकल C ++ की तरह जेनरिक नहीं हैं, बल्कि वास्तविक टेम्प्लेट हैं, लेकिन टेम्प्लेट मूल नहीं हैं, बल्कि प्रबंधित कक्षाएं हैं। इस तरह के पैटर्न की तात्कालिकता प्रबंधित कक्षाओं के निर्माण की ओर ले जाती है जिनका उपयोग बेस कक्षाओं के रूप में या विधानसभा के भीतर अन्य वर्गों के सदस्यों के रूप में किया जा सकता है। प्रबंधित टेम्पलेट [होगेंसन] में वर्णित हैं।

2.1। स्मार्ट पॉइंटर्स

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

यहाँ इस तरह के पैटर्न का एक उदाहरण है। पहला टेम्प्लेट एक बेस टेम्प्लेट है, दूसरा बेस क्लास के रूप में इस्तेमाल करने के लिए है, और तीसरा क्लास के सदस्य के रूप में। इन टेम्प्लेट में किसी ऑब्जेक्ट को हटाने के लिए डिज़ाइन किया गया टेम्प्लेट पैरामीटर (मूल) होता है। विलोपन वर्ग, डिफ़ॉल्ट रूप से, हटाए गए ऑपरेटर के साथ ऑब्जेक्ट को हटा देता है।

 //  , -  , T —   template <typename T> struct DefDeleter {    void operator()(T* p) const { delete p; } }; //  , //      //  , T —  , D — - template <typename T, typename D> public ref class ImplPtrBase : System::IDisposable {    T* m_Ptr;    void Delete()    {        if (m_Ptr != nullptr)        {            D del;            del(m_Ptr);            m_Ptr = nullptr;        }    }    ~ImplPtrBase() { Delete(); }    !ImplPtrBase() { Delete(); } protected:    ImplPtrBase(T* p) : m_Ptr(p) {}    T* Ptr() { return m_Ptr; } }; //        template <typename T, typename D = DefDeleter<T>> public ref class ImplPtr : ImplPtrBase<T, D> { protected:    ImplPtr(T* p) : ImplPtrBase(p) {} public:    property bool IsValid    {        bool get() { return (ImplPtrBase::Ptr() != nullptr); }    } }; //        template <typename T, typename D = DefDeleter<T>> public ref class ImplPtrM sealed : ImplPtrBase<T, D> { public:    ImplPtrM(T* p) : ImplPtrBase(p) {}    operator bool() { return ( ImplPtrBase::Ptr() != nullptr); }    T* operator->() { return ImplPtrBase::Ptr(); }    T* Get() { return ImplPtrBase::Ptr(); } }; 

2.2। उदाहरण का उपयोग करें

 class N //   { public:    N();    ~N();    void DoSomething(); // ... }; using NPtr = ImplPtr<N>; //   public ref class U : NPtr //  - { public:    U() : NPtr(new N()) {}    void DoSomething() { if (IsValid) Ptr()->DoSomething(); } // ... }; public ref class V //  -,   {    ImplPtrM<N> m_NPtr; //   public:    V() : m_NPtr(new N()) {}    void DoSomething() { if (m_NPtr) m_NPtr->DoSomething(); } // ... }; 

इन उदाहरणों में, कक्षाएं U और V बिना किसी अतिरिक्त प्रयास के मुक्त हो जाती हैं; उनका Dispose() N को एक पॉइंटर के लिए delete ऑपरेटर को कॉल प्रदान करता है N ImplPtrM<> का उपयोग करते हुए दूसरा विकल्प, आपको एक एकल ImplPtrM<> वर्ग में कई देशी कक्षाओं का प्रबंधन करने की अनुमति देता है।

2.3। अधिक जटिल अंतिम विकल्प

अंतिम रूप से .NET का समस्याग्रस्त पहलू है। सामान्य अनुप्रयोग परिदृश्यों में, अंतिम रूप से नहीं बुलाया जाना चाहिए; संसाधन Dispose() में जारी किए जाने चाहिए Dispose() । लेकिन आपातकालीन स्थितियों में ऐसा हो सकता है और फाइनलर्स को सही तरीके से काम करना चाहिए।

2.3.1। फाइनल लॉक

यदि मूल वर्ग DLL में स्थित है जो लोड और अनलोड को गतिशील रूप से करता है - LoadLibrary()/FreeLibrary() का उपयोग करके, तो एक स्थिति उत्पन्न हो सकती है जब DLL को अनलोड करने के बाद इस श्रेणी के उदाहरणों के संदर्भ में अप्रतिबंधित ऑब्जेक्ट होते हैं। इस मामले में, थोड़ी देर के बाद कचरा कलेक्टर उन्हें अंतिम रूप देने की कोशिश करेगा, और चूंकि डीएलएल अनलोड नहीं किया गया है, इसलिए कार्यक्रम सबसे अधिक दुर्घटना की संभावना है। (एक विशेषता सुविधा स्पष्ट रूप से आवेदन बंद होने के बाद कई सेकंड के लिए एक दुर्घटना है।) इसलिए, DLL को उतारने के बाद, अंतिम रूप से अवरुद्ध होना चाहिए। यह मूल ImplPtrBase टेम्पलेट के एक छोटे संशोधन के साथ प्राप्त किया जा सकता है।

 public ref class DllFlag { protected:    static bool s_Loaded = false; public:    static void SetLoaded(bool loaded) { s_Loaded = loaded; } }; template <typename T, typename D> public ref class ImplPtrBase : DllFlag, System::IDisposable { // ...    !ImplPtrBase() { if (s_Loaded) Delete(); } // ... }; 

DLL को लोड करने के बाद, आपको DllFlag::SetLoaded(true) , और DllFlag::SetLoaded(false) अनलोड करने से पहले DllFlag::SetLoaded(false) कॉल करने की आवश्यकता है।

2.3.2। SafeHandle का उपयोग करना

SafeHandle क्लास एक जटिल और सबसे विश्वसनीय अंतिम एल्गोरिथ्म को लागू करता है, देखें [रिक्टर]। SafeHandle का उपयोग करने के लिए ImplPtrBase<> टेम्पलेट पुन: डिज़ाइन किया जा सकता है। शेष टेम्पलेट्स को बदलने की आवश्यकता नहीं है।

 using SH = System::Runtime::InteropServices::SafeHandle; using PtrType = System::IntPtr; template <typename T, typename D> public ref class ImplPtrBase : SH { protected:    ImplPtrBase(T* p) : SH(PtrType::Zero, true)    {        handle = PtrType(p);    }    T* Ptr() { return static_cast<T*>(handle.ToPointer()); }    bool ReleaseHandle() override    {        if (!IsInvalid)        {            D del;            del(Ptr());            handle = PtrType::Zero;        }        return true;    } public:    property bool IsInvalid    {        bool get() override        {            return (handle == PtrType::Zero);        }    } }; 

संदर्भ

[रिक्टर]
रिक्टर, जेफरी। मंच पर प्रोग्रामिंग Microsoft .NET फ्रेमवर्क 4.5 C # में। चौथा संस्करण: प्रति। अंग्रेजी से - सेंट पीटर्सबर्ग: पीटर, 2016।

[Cwalina]
Tsvalina, Krzhishtov। अब्राम, ब्रैड। सॉफ्टवेयर परियोजनाओं की संरचना: पुन: प्रयोज्य .NET पुस्तकालयों के लिए सम्मेलनों, मुहावरों और टेम्पलेट्स।: अनुवाद। अंग्रेजी से - एम।: एलएलसी “आई.डी. विलियम्स, 2011।

[Hogenson]
होगेंसन, गॉर्डन। C ++ / CLI: .NET पर्यावरण के लिए दृश्य C ++ भाषा ।: प्रति। अंग्रेजी से - एम।: एलएलसी “आई.डी. विलियम्स, 2007।