क्या साझा_ptr

Question

के मौजूदा उदाहरण पर हटाए गए क्रिया को बदलने का कोई तरीका है मेरे पास एक ऐसा कार्य है जहां मैं क्लीनअप कार्रवाई 90% करता हूं, लेकिन 10% में मैं कुछ अन्य कार्यवाही करना चाहता हूं।

क्या कुछ मानक स्कॉप्ड नियंत्रण का उपयोग करने के लिए shared_ptr<> का उपयोग करने का कोई तरीका है ताकि प्रारंभ में इसमें एक हटाई गई कार्रवाई हो और बाद में फ़ंक्शन में हटाए गए क्रिया को बदला जा सके?

shared_ptr<T> ptr(new T, std::mem_fun_ref(&T::deleteMe)); 
ptr.pn.d = std::mem_fun_ref(&T::queueMe); 

Answer 1

मुझे नहीं लगता कि आप Deleter बदल सकते हैं एक बार shared_ptr बनाया गया था है।

लेकिन आप ऐसा क्यों करेंगे? आम तौर पर, जब आप कोई ऑब्जेक्ट बनाते हैं, तो आप तुरंत जानते हैं कि इसे कैसे नष्ट किया जाना चाहिए। यह बदलने की संभावना नहीं है।

यदि आपको वास्तव में कुछ विशिष्ट उपचार करना चाहिए, तो भी आप एक कस्टम डिलीटर प्रदान कर सकते हैं जो आवश्यक तर्कों के आधार पर विशेष चीजें करता है।

Answer 2

डिलीटर बदलने की आवश्यकता के लिए एक वैध कारण है। उदाहरण के लिए इसे लें:

int foo(std::shared_ptr<double>& bar) { 
    ... 
    std::shared_ptr<double> p(my_allocator<double>::allocate(), my_deleter<double>()); 
    bar.swap(p); // this copies the deleter 
    ... 
} 

int main(int, char**) { 
    std::shared_ptr<double> d; 
    foo(d); // d now has a new deleter that will be called when it goes out of scope 
    ... 
} 

इस मामले में foo() फ़ंक्शन कुछ विशेष आवंटकों का उपयोग करके डबल * आवंटित करता है। इसे उस स्मृति को एक विशेष तरीके से मुक्त करने की भी आवश्यकता है। कॉलर को यह जानने की आवश्यकता नहीं है कि स्मृति को कैसे मुक्त किया जाए।

Answer 3

यह कोई समझ नहीं आता है, क्योंकि shared_ptr की कोई भी संख्या मूल्य के स्वामित्व का प्रबंधन करती है। आपको उन सभी को संशोधित करने की आवश्यकता होगी, और यह संभव नहीं है। चलो भूलें कि एक नियंत्रण ब्लॉक एक कार्यान्वयन विस्तार है, इसलिए "आह, लेकिन इसे नियंत्रण ब्लॉक में बदलना" काम नहीं करेगा।

हटाए गए कार्यों को shared_ptr के स्वामित्व वाले उदाहरण द्वारा नियंत्रित किया जाना चाहिए, उदा।

class C { 
... 
    void (C::action*)() { &C::action1 }; 
    void action1(); 
    void action2(); 
    ~C() { (this->*action)(); } 
}; 

void test() { 
    std::shared_ptr<C> a; 
    a->action = &C::action2; 
    // action2 gets invoked once `a` falls out of scope 
}