Discussion :

[f56bre]

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.

[3DArchi]

Salut,
La conversion est implicite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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 ...

[f56bre]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[3DArchi]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[f56bre]

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