Différence entre `const shared_ptr ` et `shared_ptr `?

J’écris une méthode d’accesseur pour un pointeur partagé en C ++ qui va quelque chose comme ceci:

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

Donc, pour prendre en charge la getBar() de getBar() le type de retour devrait être un boost::shared_ptr qui empêche la modification de la Bar il pointe. Je pense que shared_ptr est le type que je veux retourner pour faire cela, alors que const shared_ptr empêcherait la réaffectation du pointeur lui-même de pointer vers une autre Bar mais de modifier la Bar laquelle il pointe. .. Cependant, je ne suis pas sûr. J’apprécierais que quelqu’un qui sache à coup sûr puisse le confirmer ou me corriger si je me trompe. Merci!

Tu as raison. shared_ptr p; est similaire à const T * p; (ou, de manière équivalente, T const * p; ), c’est-à-dire que l’object pointu est const alors que const shared_ptr p; est similaire à T* const p; ce qui signifie que p est const . En résumé:

 shared_ptr p; ---> T * p; : nothing is const const shared_ptr p; ---> T * const p; : p is const shared_ptr p; ---> const T * p; <=> T const * p; : *p is const const shared_ptr p; ---> const T * const p; <=> T const * const p; : p and *p are const. 

La même chose vaut pour weak_ptr et unique_ptr .

boost::shared_ptr empêche la modification de l’object Bar via le pointeur partagé. En tant que valeur de retour, le const dans boost::shared_ptr const signifie que vous ne pouvez pas appeler une fonction non-const sur le temporaire renvoyé; si c’était pour 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: const modifie ce qui le précède: dans boost::shared_ptr , la Bar ; dans boost::shared_ptr const , c’est l’instanciation (l’expression boost::shared_ptr qui est const.

 #Check this simple code to understand... copy-paste the below code to check on any c++11 comstackr #include  using namespace std; class A { public: int a = 5; }; shared_ptr f1() { const shared_ptr sA(new A); shared_ptr sA2(new A); sA = sA2; // comstack-error return sA; } shared_ptr f2() { shared_ptr sA(new A); sA->a = 4; // comstack-error return sA; } int main(int argc, char** argv) { f1(); f2(); return 0; }