एक स्मार्ट पॉइंटर अपने कन्स्ट्रक्टर में मेरे लिए नया() क्यों नहीं कॉल कर सकता है?

Question

क्या एक स्मार्ट पॉइंटर लिखना संभव है जो ऑब्जेक्ट को अपने कन्स्ट्रक्टर में आवंटित करता है - डेवलपर को new पर कॉल करने के बजाय? दूसरे शब्दों में, बजाय लिखने के लिए:

std::unique_ptr<myClass> my_ptr(new myClass(arg1, arg2))

... एक लिख सकते हैं:

std::smarter_ptr<myClass> my_ptr(arg1, arg2)

भाषा वाक्य रचना इस व्यक्त करने में सक्षम है? क्या यह वांछनीय होगा? घृणित? मैं इस गलती के खिलाफ की रक्षा करने के विशेष रूप से सोच रहा हूँ (अपने आप को जो मैं कर दिया है, निश्चित रूप से):

myFunction(std::unique_ptr<myClass>(new myClass()), std::unique_ptr<myClass>(new myClass()))

... जो लीक जोखिम जो भी वस्तु पहले आवंटित किया जाता है, तो दूसरा आवंटन होता है और फेंकता पहले ऑब्जेक्ट को अपने स्मार्ट पॉइंटर में सुरक्षित रूप से ensconced से पहले। लेकिन क्या एक बेहतर सूचक वास्तव में यह सुरक्षित बनाएगा?

Answer 1

make_shared() के कार्यान्वयन को देखें। यह एक नई वस्तु आवंटित करता है और इसमें से shared_ptr बनाता है।

Answer 2

यह सी ++ 11 के साथ नया संभव है जिसमें perfect forwarding और विविध टेम्पलेट जोड़े गए हैं।

Answer 3

यह वही समस्या है जो std::find और std::find_if की आवश्यकता है। आप new myClass(arg1) मामले में shared_ptr के मौजूदा सीटीआर से इस सीटीआर को अलग नहीं कर सकते हैं। तर्कों की संख्या बराबर है, और arg1 किसी भी प्रकार का हो सकता है।

इसलिए, आप एक और नाम की जरूरत है, और कहा कि make_shared

Answer 4

सामान्य तौर पर, यह एक स्मार्ट सूचक के निर्माता के साथ नहीं किया जा सकता है; स्मार्ट पॉइंटर को निष्क्रिय करने के लिए पॉइंटर तर्क का उपयोग किया जाना चाहिए, या एक नई वस्तु बनाने के लिए अग्रेषित किया जाना चाहिए या नहीं, इस पर एक अस्पष्टता होगी।

यह एक कारखाने समारोह के साथ किया जा सकता है, उदाहरण के लिए:

template <typename T, typename... Args> 
std::unique_ptr<T> make_unique(Args&&... args) { 
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); 
} 

आप std::shared_ptr का उपयोग कर रहे हैं, तो आप std::make_shared उपयोग कर सकते हैं। यह केवल एक स्मृति आवंटन की आवश्यकता का लाभ देता है, जहां std::shared_ptr<T>(new T) को ऑब्जेक्ट के लिए एक और साझा संदर्भ गणना के लिए एक सेकंड की आवश्यकता होगी।