`Const share_ptr <T>` और `साझा_ptr <const T>` के बीच अंतर?

Question

मैं C ++ में एक साझा पॉइंटर के लिए एक एक्सेसर विधि लिख रहा हूं जो कुछ इस प्रकार है:

class Foo {
public:
    return_type getBar() const {
        return m_bar;
    }

private:
    boost::shared_ptr<Bar> m_bar;
}

तो getBar()रिटर्न प्रकार के कॉन्स्ट-नेस का समर्थन करने के लिए ऐसा होना चाहिए boost::shared_ptrजो Barइसे इंगित करने से रोकता है। मेरा अनुमान है कि shared_ptr<const Bar>वह वह प्रकार है जो मैं उसे करने के लिए वापस जाना चाहता हूं, जबकि const shared_ptr<Bar>पॉइंटर के पुन: असाइनमेंट को रोकने के लिए खुद को एक अलग इंगित करने के लिए रोकना होगा , Barलेकिन Barइसे संशोधित करने की अनुमति देता है ... हालांकि, मुझे यकीन नहीं है। मैं इसे सराहता हूँ अगर कोई व्यक्ति जो निश्चित रूप से जानता है वह इस बात की पुष्टि कर सकता है, या अगर मुझे यह गलत लगा तो मुझे सही कर सकता है। धन्यवाद!

Comments

जैसा आपने कहा वैसा ही हुआ। आप ऑपरेटरों के लिए प्रलेखन को देख सकते हैं *और ->इसकी पुष्टि कर सकते हैं।

— सिआम

बीच क्या अंतर है T *constऔर T const *? जो उसी।

@ H2CO3 बिल्कुल नहीं। constसामान्य रूप से संशोधित क्या यह _precedes, तो T *constएक है constकरने के लिए सूचक Tहै, और T const*करने के लिए एक सूचक है const T। और यह सबसे अच्छा है कि constइसे पूर्ववर्ती कुछ भी नहीं के साथ उपयोग करने से बचें ।

— जेम्स कंज

@JamesKanze, H2CO3 की बात है कि: के बीच का अंतर T *constऔर T const *के बीच अंतर के रूप में ही है const shared_ptr<T>औरshared_ptr<const T>

— जोनाथन Wakely

@JamesKanze ओह, लेकिन हाँ। T *constनॉन-कास्ट के लिए एक कास्ट पॉइंटर है T, ऐसा ही है const shared_ptr<T>। इसके विपरीत, T const *एक नॉन-कास्ट पॉइंटर है const T, ऐसा है shared_ptr<const T>।

Answer 1

तुम सही हो। shared_ptr<const T> p;के समान है const T * p;(या, समतुल्य रूप, T const * p;), यह है कि, नुकीली वस्तु है const, जबकि const shared_ptr<T> p;के समान है T* const p;जिसका अर्थ है कि pहै const। संक्षेप में:

shared_ptr<T> p;             ---> T * p;                                    : nothing is const
const shared_ptr<T> p;       ---> T * const p;                              : p is const
shared_ptr<const T> p;       ---> const T * p;       <=> T const * p;       : *p is const
const shared_ptr<const T> p; ---> const T * const p; <=> T const * const p; : p and *p are const.

उसी के लिए रखती है weak_ptrऔर unique_ptr।

Comments

आपने एक प्रश्न का उत्तर भी दिया था जो मैंने अपने सिर के पिछले हिस्से में रेगुलर पॉइंटर्स (कॉन्स्ट टी * बनाम टी * कॉन्स्ट बनाम टी कॉन्स्ट *) के बारे में दिया था। :) मैंने इसका उल्लेख नहीं किया क्योंकि मैं नहीं चाहता था कि एसओ पर मेरा दावा बहुत व्यापक हो, और यह मेरे वर्तमान कार्य के लिए उचित था। किसी भी तरह, मुझे लगता है कि मैं अब बहुत अच्छी तरह से समझता हूं। धन्यवाद!

— डेव लिलथून

मुझे खुशी है कि इसने मदद की। एक अंतिम टिप है कि मैं के बारे में याद करने के लिए उपयोग const T* p;', 'T const * p;और T * const p। *एक विभाजक के रूप में इस अर्थ में देखें कि जो है constवही के समान है *।

— कैसियो नेरी

अंगूठे का मेरा नियम यह है कि constहमेशा बाईं ओर की चीज को संदर्भित करता है। यदि बाईं ओर कुछ भी नहीं है, तो यह दाईं ओर की चीज है।

— hochl

होची - कांस्ट टी * पी के बारे में कैसे; T const * p के बराबर ;?

— Vlad

कैसियो, आप यह जोड़ सकते हैं कि लौटाए गए प्रकारों के मामले में बांटे गए कास्ट शेयर्ड_एप्ट्र <टी> के मामले में, इसका उपयोग नॉन-कास्ट कार्यों में नहीं किया जा सकता है, जबकि यह कॉन्स्ट पॉइंटर्स के लिए सही नहीं है।

— Vlad

Answer 2

boost::shared_ptr<Bar const>Barसाझा सूचक के माध्यम से वस्तु के संशोधन को रोकता है । वापसी मूल्य के रूप में, इस का boost::shared_ptr<Bar> constमतलब है कि आप लौटे अस्थायी पर एक गैर-कास्ट फ़ंक्शन नहीं कह सकते हैं; यदि यह एक वास्तविक सूचक (जैसे Bar* const) के लिए था, तो इसे पूरी तरह से नजरअंदाज कर दिया जाएगा।

सामान्य तौर पर, यहां भी, सामान्य नियम लागू होते हैं: constयह बताता है कि इससे पहले क्या होता है: में boost::shared_ptr<Bar const>, ए Bar; में boost::shared_ptr<Bar> const, यह तात्कालिकता है (अभिव्यक्ति boost::shared_ptr<Bar>जो कास्ट है।

Comments

@ गेटटॉपिच तो आप कर सकते deleteहैं।

— मार्सिन

@Marcin क्या आप विस्तृत कर सकते हैं?

— गैटोपिच

Answer 3

#Check this simple code to understand... copy-paste the below code to check on any c++11 compiler

#include <memory>
using namespace std;

class A {
    public:
        int a = 5;
};

shared_ptr<A> f1() {
    const shared_ptr<A> sA(new A);
    shared_ptr<A> sA2(new A);
    sA = sA2; // compile-error
    return sA;
}

shared_ptr<A> f2() {
    shared_ptr<const A> sA(new A);
    sA->a = 4; // compile-error
    return sA;
}

int main(int argc, char** argv) {
    f1();
    f2();
    return 0;
}

Comments

क्या मैं std::make_shared()(C ++ 14 के बाद से) के उपयोग का सुझाव दे सकता हूं ।

— जोएल बोडेनमैन

Answer 4

मैं @ कैसियो नेरी के जवाब के आधार पर एक साधारण डेमोस्ट्रेशन करना चाहूंगा:

#include <memory>

int main(){
    std::shared_ptr<int> i = std::make_shared<int>(1);
    std::shared_ptr<int const> ci;

    // i = ci; // compile error
    ci = i;
    std::cout << *i << "\t" << *ci << std::endl; // both will be 1

    *i = 2;
    std::cout << *i << "\t" << *ci << std::endl; // both will be 2

    i = std::make_shared<int>(3);
    std::cout << *i << "\t" << *ci << std::endl; // only *i has changed

    // *ci = 20; // compile error
    ci = std::make_shared<int>(5);
    std::cout << *i << "\t" << *ci << std::endl; // only *ci has changed

}