`কনস্টেন্ড_ট্রের <T>` এবং `শেয়ারড_পিটার <কনট টি> between এর মধ্যে পার্থক্য?

Question

আমি সি ++ তে ভাগ করা পয়েন্টারের জন্য একটি অ্যাকসেসর পদ্ধতি লিখছি যা এরকম কিছু হয়:

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

@ জামেসকাঞ্জ ওহ তবে হ্যাঁ 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;(অথবা এবং, equivalently, 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সর্বদা এর বাম দিকের জিনিসটিকে বোঝায়। যদি কিছুই বাম দিকে না থাকে তবে ডানদিকে জিনিস।

— হচল

হোচি - কীভাবে কনস্টেন্ট টি * পি; টি কনস্ট * পি;? এর সমতুল্য

— ভ্লাদ

ক্যাসিও, আপনি যুক্ত করতে পারেন যে রিটার্ন করা টাইপ কনস্ট শেয়ারড_সিপি <টি> এর ক্ষেত্রে এটি কনস্ট্যান্ট ফাংশনে ব্যবহার করা যাবে না যখন কনস্ট পয়েন্টারগুলির ক্ষেত্রে এটি সত্য নয় not

— ভ্লাদ

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

@gatopeich তাই আপনি যা করতে পারেন deleteতা।

— মার্সিন

@ মার্সিন আপনি কি বর্ণনা করতে পারবেন?

— গাটোপিচ

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()(সি ++ 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

}