polymorphisme entre shared_ptr<B> et shared_ptr<A>

Version imprimable

Salut!

Voici mon problème:
J'ai une classe Interface (pour l'exemple ;) )
Code:

1 2 3 4 5 6 class Interface { // cette fonction doit retourner un pointeur vers un objet "copie" qu'elle a crée Interface * getIndependentCopy(); };
que j'implémente avec Implementation (toujours pour l'exemple)
Code:

1 2 3 class Implementation : public Interface { Implementation * getIndependentCopy(); }
On remarque que getIndependentCopy de Implementation retourne un pointeur de Implementation et non de Interface, mais le compilo et content et moi aussi.

je voudrais utiliser des shared_ptr pour le retour de getIndependentCopy, pour empecher d'avoir de la mémoire allouée dans la nature, sans personne qui ne s'en occupe. Ce code est
Code:

1 2 3 4 5 6 7 8 9 10 class Interface { // cette fonction doit retourner un pointeur vers un objet "copie" qu'elle a crée boost::shared_ptr<Interface> getIndependentCopy(); }; class Implementation : public Interface { boost::shared_ptr<Implementation> getIndependentCopy(); }
mais je reçois alors à la compilation l'erreur "'Implementation ::getIndependentCopy' : overriding virtual function return type differs and is not covariant from 'Interface::getIndependentCopy'

Sans doute du au fait que boost::shared_ptr<Implementation> ne dérive pas de boost::shared_ptr<Interface>???

Est ce que quelqu'un saurait comment faire pour résoudre ce problème?
Merci!

Bonjour,

Il me semble que la seule solution connue pour contourner ce problème est d'utiliser un pattern NVI :

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
36
37
38
39
40
41
42
43
44
 
#include <iostream>
#include <memory>
 
class Interface 
{
protected:
   virtual Interface* getIndependentCopyImpl() const
   {
      std::cout << "interface" << std::endl;
      return new Interface(*this);
   }
public:
   std::shared_ptr<Interface> getIndependentCopy() const
   {
      std::cout << "interface" << std::endl;
      return std::shared_ptr<Interface>(getIndependentCopyImpl());
   }
};
 
class Implementation : public Interface  
{
protected:
   virtual Implementation* getIndependentCopyImpl() const
   {
      std::cout << "implementation" << std::endl;
      return new Implementation(*this);
   }
public:
   std::shared_ptr<Implementation> getIndependentCopy() const
   {
      std::cout << "interface" << std::endl;
      return std::shared_ptr<Implementation>(getIndependentCopyImpl());
   }
};
 
int main()
{
   Interface* i = new Implementation();
   std::shared_ptr<Interface> ptr_i = i->getIndependentCopy();
 
   Implementation* i2 = new Implementation();
   std::shared_ptr<Implementation> ptr_i2 = i2->getIndependentCopy();
}

C'est bon, j'ai fait comme ça et ça marche bien.

On doit mettre
Code:

1 2 3 4 5 std::shared_ptr<Implementation> getIndependentCopy() const { std::cout << "implementation" << std::endl; return std::shared_ptr<Implementation>(getIndependentCopyImpl()); }
en plus dans le code de chaque implémentation, mais à part ça, c'est parfait!!! :ccool: