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