Perbedaan antara `const shared_ptr <T>` dan `shared_ptr <const T>`?

Saya menulis metode pengakses untuk penunjuk bersama di C ++ yang berjalan seperti ini:

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

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

Jadi untuk mendukung keteguhan getBar()jenis kembalian haruslah boost::shared_ptryang mencegah modifikasi dari Barpoin itu. Dugaan saya adalah shared_ptr<const Bar>tipe yang ingin saya kembalikan untuk melakukan itu, sedangkan const shared_ptr<Bar>akan mencegah penugasan ulang pointer itu sendiri untuk menunjuk ke yang berbeda Bartetapi memungkinkan modifikasi dari Baryang ditunjukkannya ... Namun, saya tidak yakin. Saya akan menghargai jika seseorang yang tahu pasti bisa mengkonfirmasi ini, atau mengoreksi saya jika saya salah. Terima kasih!

Kamu benar. shared_ptr<const T> p;mirip dengan const T * p;(atau, sama, T const * p;), yaitu menunjuk objek adalah constsedangkan const shared_ptr<T> p;mirip dengan T* const p;yang artinya padalah const. Singkatnya:

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.

Hal yang sama berlaku untuk weak_ptrdan unique_ptr.

boost::shared_ptr<Bar const>mencegah modifikasi Barobjek melalui penunjuk bersama. Sebagai nilai yang dikembalikan, const in boost::shared_ptr<Bar> constberarti Anda tidak dapat memanggil fungsi non-const pada fungsi sementara yang dikembalikan; jika itu untuk penunjuk nyata (misalnya Bar* const), itu akan sepenuhnya diabaikan.

Secara umum, bahkan di sini, aturan yang biasa berlaku: constmemodifikasi apa yang mendahuluinya: in boost::shared_ptr<Bar const>, the Bar; di boost::shared_ptr<Bar> const, itu adalah instantiation (ekspresi boost::shared_ptr<Bar>yang const.

#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;
}

Saya ingin demo sederhana berdasarkan jawaban @Cassio Neri:

#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

}