Różnica między `const shared_ptr <T>` i `shared_ptr <const T>`?

Piszę metodę akcesora dla współdzielonego wskaźnika w C ++, która wygląda mniej więcej tak:

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

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

Tak więc, aby obsługiwać stałą getBar()zwracanego typu, powinno być a, boost::shared_ptrktóre zapobiega modyfikacji wskazanego przez Barniego. Moje przypuszczenie jest to, że shared_ptr<const Bar>jest to rodzaj chcę wrócić do tego, natomiast const shared_ptr<Bar>uniemożliwia zmiany przeznaczenia wskaźnik się do punktu do innego Bar, ale umożliwiają modyfikację Barże wskazuje ... Jednak nie jestem pewien. Byłbym wdzięczny, gdyby ktoś, kto wie na pewno, mógł to potwierdzić lub poprawić mnie, jeśli źle zrozumiałem. Dzięki!

Masz rację. shared_ptr<const T> p;jest podobny do const T * p;(lub równoważnie T const * p;), to znaczy wskazany obiekt jest, constpodczas gdy const shared_ptr<T> p;jest podobny, T* const p;co oznacza, że pjest const. W podsumowaniu:

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.

To samo dotyczy weak_ptri unique_ptr.

boost::shared_ptr<Bar const>zapobiega modyfikacji Barobiektu za pomocą udostępnionego wskaźnika. Jako wartość zwracana, stała w boost::shared_ptr<Bar> constoznacza, że ​​nie można wywołać funkcji innej niż stała na zwróconym obiekcie tymczasowym; gdyby dotyczył prawdziwego wskaźnika (np. Bar* const), zostałby całkowicie zignorowany.

Generalnie nawet tutaj obowiązują zwykłe reguły: constmodyfikuje to, co go poprzedza: in boost::shared_ptr<Bar const>, the Bar; w boost::shared_ptr<Bar> const, jest to instancja (wyrażenie, boost::shared_ptr<Bar>które jest stałą.

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

Chciałbym przeprowadzić prostą demonstrację opartą na odpowiedzi @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

}