Passage d'un shared_ptr sur une constante à une fonction

Bonjour,

Je souhaite passer aux smart_ptr de boost mais je me pose une question.
La signature d'une fonction ne modifiant pas un paramètre est par exemple
void setParametre( const MaClasse& );

qu'en est il avec un shared_ptr ?
la signature void setParametre( shared_ptr<MaClasse> const & ) laisse la porte ouverte à une modification du paramètre dans la fonction.
la signature void setParametre( shared_ptr<const MaClasse> const &) bloque bien toute modification du paramètre mais oblige à un cast vers une variable membre (non const) dans le cas ou l'on veut faire un mutateur.

Quel est selon vous la meilleure manière de procéder?

Merci d'avance.

Salut,
La conversion est implicite :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

#include <iostream> #include <boost\shared_ptr.hpp> #include <boost\make_shared.hpp>   struct dummy { void fn() { std::cout<<"non_const\n"; }   void fn() const { std::cout<<"const\n"; } };   void call_non_const(boost::shared_ptr<dummy> const&p) { p->fn();// appel de la fonction non const }   void call_const(boost::shared_ptr<const dummy> const&p) { p->fn(); // appel de la fonction const }   int main() { boost::shared_ptr<dummy> ptr = boost::make_shared<dummy>(); call_non_const(ptr); call_const(ptr);   return 0; }

---

Citation:

---

Envoyé par f56bre

dans le cas ou l'on veut faire un mutateur.
Quel est selon vous la meilleure manière de procéder?

---

Ben dans ce cas ton objet n'est pas constant ...

Merci pour ta réponse.
Par contre concernant le mutateur mon problème est le suivant :
sans shared_ptr on fait ça :

Code:

---

1 2 3 4 5 6 7

MaClasse { public: void set( const AutreClasse& var ){ m_var = var; } // ok private: AutreClasse m_var; };

---

Avec un shared_ptr l'équivalent donnerait ça :

Code:

---

1 2 3 4 5 6 7 8

MaClasse { public: void set( const shared_ptr<const AutreClasse>& var ){ m_var = var; } // erreur de compilation private: shared_ptr<AutreClasse> m_var; };

---

Mais ça ne fonctionne pas. Quelle est la meilleur façon d'implémenter une solution équivalente à la solution sans shared_ptr de manière sûre et optimisée?

Normal. Cela ne fait pas une copie profonde de l'objet pointé mais juste du pointeur. C'est strictement équivalent à vouloir faire :

Code:

---

1 2 3 4 5 6 7

struct MaClasse { public: void set( const AutreClasse * var ){ m_var = var; } // Erreur private: AutreClasse * m_var; };

---

Tu as exactement la même erreur ... et heureusement car un pointeur intelligent doit quand même avoir une utilisation au plus près d'un pointeur nu.

Effectivement, vu sous cet angle...:roll:
Merci pour tes réponses