Diferença entre `const shared_ptr <T>` e `shared_ptr <const T>`?

Estou escrevendo um método de acesso para um ponteiro compartilhado em C ++ que funciona mais ou menos assim:

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

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

Portanto, para oferecer suporte à constância getBar()do tipo de retorno deve ser um boost::shared_ptrque evite a modificação do que Barele aponta. Meu palpite é que esse shared_ptr<const Bar>é o tipo que eu quero retornar para fazer isso, ao passo const shared_ptr<Bar>que impediria a reatribuição do próprio ponteiro para apontar para um diferente, Barmas permitiria a modificação do para o Barqual ele aponta ... No entanto, não tenho certeza. Eu agradeceria se alguém que sabe com certeza pudesse confirmar isso ou me corrigir se eu errar. Obrigado!

Você está certo. shared_ptr<const T> p;é semelhante a const T * p;(ou, equivalentemente, T const * p;), isto é, o objeto apontado é constenquanto const shared_ptr<T> p;é semelhante ao T* const p;que significa que pé const. Em suma:

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.

O mesmo vale para weak_ptre unique_ptr.

boost::shared_ptr<Bar const>impede a modificação do Barobjeto por meio do ponteiro compartilhado. Como um valor de retorno, o const in boost::shared_ptr<Bar> constsignifica que você não pode chamar uma função não const no temporário retornado; se fosse por um ponteiro real (por exemplo Bar* const), seria completamente ignorado.

Em geral, mesmo aqui, as regras usuais se aplicam: constmodifica o que o precede: em boost::shared_ptr<Bar const>, o Bar; in boost::shared_ptr<Bar> const, é a instanciação (a expressão boost::shared_ptr<Bar>que é 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;
}

Gostaria de fazer uma demonstração simples baseada na resposta de @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

}