Разница между `const shared_ptr <T>` и `shared_ptr <const T>`?

Я пишу метод доступа для общего указателя на 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что он указывает ... Однако я не уверен. Буду признателен, если кто-то, кто знает наверняка, подтвердит это или поправит меня, если я ошибся. Спасибо!

Ты прав. 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.

boost::shared_ptr<Bar const>предотвращает изменение Barобъекта через общий указатель. В качестве возвращаемого значения константа in boost::shared_ptr<Bar> constозначает, что вы не можете вызвать неконстантную функцию для возвращаемой временной; если бы это был реальный указатель (например Bar* const), он был бы полностью проигнорирован.

В общем, даже здесь действуют обычные правила: constизменяет то, что ему предшествует: in boost::shared_ptr<Bar const>, the Bar; in boost::shared_ptr<Bar> const, это экземпляр (выражение boost::shared_ptr<Bar>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;
}

Я хотел бы провести простую демонстрацию на основе ответа @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

}