Différence entre `const shared_ptr <T>` et `shared_ptr <const T>`?

J'écris une méthode d'accesseur pour un pointeur partagé en C ++ qui ressemble à ceci:

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

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

Donc, pour prendre en charge la const-ness du getBar()type de retour devrait être un boost::shared_ptrqui empêche la modification du Barpoint vers lequel il pointe. Je suppose que shared_ptr<const Bar>c'est le type que je veux retourner pour faire cela, alors que const shared_ptr<Bar>cela empêcherait la réaffectation du pointeur lui-même pour pointer vers un autre Barmais permettrait de modifier le Barpoint vers lequel il pointe ... Cependant, je ne suis pas sûr. J'apprécierais que quelqu'un qui sait avec certitude puisse confirmer cela ou me corriger si je me trompe. Merci!

Vous avez raison. shared_ptr<const T> p;est similaire à const T * p;(ou, de manière équivalente, T const * p;), c'est-à-dire que l'objet pointé est constalors que const shared_ptr<T> p;est similaire à T* const p;ce qui signifie que pc'est const. En résumé:

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.

La même chose vaut pour weak_ptret unique_ptr.

boost::shared_ptr<Bar const>empêche la modification de l' Barobjet via le pointeur partagé. En tant que valeur de retour, le const in boost::shared_ptr<Bar> constsignifie que vous ne pouvez pas appeler une fonction non-const sur le temporaire renvoyé; s'il s'agissait d'un vrai pointeur (par exemple Bar* const), il serait complètement ignoré.

En général, même ici, les règles habituelles s'appliquent: constmodifie ce qui le précède: in boost::shared_ptr<Bar const>, the Bar; in boost::shared_ptr<Bar> const, c'est l'instanciation (l'expression boost::shared_ptr<Bar>qui est 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;
}

J'aimerais une simple démonstration basée sur la réponse 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

}