QScopedPointerunique_ptr से कड़ाई से कमजोर है क्योंकि यह चाल semantics का समर्थन नहीं करता है।
इसकी कार्यक्षमता अन्यथा बेहद समान है।
ले जाएं अर्थशास्त्र बहुत ही उपयोगी हैं, और गलती से समस्याओं का कारण बनने के लिए गलती से उनका उपयोग करना बेहद दुर्लभ है। तो वे बहुत हानिकारक (अधिक आम तौर पर) सहायक से बहुत उपयोगी हैं।
एकमात्र कारण के बारे में आपको QScopedPointer का उपयोग करना चाहिए मौजूदा कोड अड्डों के साथ अंतःक्रियाशीलता; और यहां तक कि, वे कितने समान हैं, एक एडाप्टर बहुत आसान होगा।
तो यदि आपको अनुकूलित करने की आवश्यकता नहीं है, तो unique_ptr का उपयोग करें।
अब मैं अनुकूलन पर चर्चा करूंगा।
मुश्किल भाग QScopedPointer पर दूसरा पैरामीटर है। यह बहुत ही unique_ptr के दूसरे पैरामीटर से मेल खाता है।
unique_ptr में राज्यव्यापी deleters की अनुमति है। QScopedPointer में वे नहीं हैं।
static void cleanup(T* pointer)
एक सुंदर वन-टू-वन आधार में
void operator()(T* pointer)const
unique_ptr में
से मेल खाती है।तो:
template<class QDelete>
struct std_deleter {
template<class T>
void operator()(T* target) const {
QDelete::cleanup(target);
}
};
एक स्टडी डिलीटर के लिए एक क्यूटी डिलीटर को मानचित्र करता है। दूसरी तरह के Deleter राज्यविहीन जा रहा द्वारा सीमित है:
template<class Std_deleter>
struct Qt_deleter {
template<class T>
static void cleanup(T* target) {
static_assert(std::is_empty<Std_deleter>{}, "Only works with stateless deleters");
Std_deleter{}(target);
}
};
अब हम परिवर्तित कर सकते हैं:
template<class T, class D>
QScopedPointer<T, Qt_deleter<D>>
to_qt(std::unique_ptr<T, D>&& src) {
return src.release();
}
template<class T, class D>
QScopedPointer<T, Qt_deleter<D>>
to_qt(std::unique_ptr<T[], D>&& src) {
return src.release();
}
template<class T>
QScopedPointer<T>
to_qt(std::unique_ptr<T>&& src) {
return src.release();
}
template<class T>
QScopedPointer<T, QScopedPointerArrayDeleter>
to_qt(std::unique_ptr<T[]>&& src) {
return src.release();
}
template<
class T, class D, class R=std::unique_ptr<T, std_deleter<D> >
>
to_std(QScopedPointer<T, D>&& src) {
return R(src.take()); // must be explicit
}
template<class T, class R=std::unique_ptr<T>>
to_std(QScopedPointer<T>&& src) {
return R(src.take()); // must be explicit
}
template<class T, class R=std::unique_ptr<T[]>>
to_std(QScopedPointer<T,QScopedPointerArrayDeleter >&& src) {
return R(src.take()); // must be explicit
}
जो केवल कारण है कि आप QScopedPointer का उपयोग करेंगे शामिल किया गया। कुछ कोने के मामले हैं - डिफ़ॉल्ट डिलीटर QScopedPointer को डिफ़ॉल्ट std::unique_ptr और इसके विपरीत में परिवर्तित किया जाना चाहिए।
सरणी QScopedPointer हटाएं unique_ptr<T[]> और इसके विपरीत में परिवर्तित किया जाना चाहिए।
अन्य मामलों में, मैं बस डिलीटर को लपेटता हूं। सिद्धांत रूप में, वास्तव में फैंसी चाल का ध्यान रखना होगा कि आने वाले डिलीटर को पहले ही लपेट लिया गया था और रैपिंग को उलट दिया गया था, लेकिन यदि आपका कोड ऐसा कर रहा है तो कई दौर-यात्राएं शायद पहले ही कुछ गलत हैं।
मैं 'std :: unique_ptr' का उपयोग करूंगा। – NathanOliver
मैं कह सकता हूं कि मैंने क्यूटी स्मार्ट पॉइंटर्स का उपयोग कम कर दिया है और इसके बजाय 'std :: shared_ptr' और' std :: unique_ptr' का उपयोग करने के लिए स्थानांतरित हो गया है। – drescherjm
जब भी मेरे पास मानक लाइब्रेरी और एक अलग से कक्षा के बीच कोई विकल्प होता है, तो मैं हमेशा मानक लाइब्रेरी चुनता हूं जब तक कि कोई अनिवार्य कारण न हो। ऐसा एक अनिवार्य कारण होगा यदि आपको कोड के साथ इंटरऑपरेबिलिटी की आवश्यकता होती है जो दूसरे प्रकार का उपयोग करती है। –