Discussion :

[Xemame]

Salut!

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

Code :

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

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 :

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

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 :

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

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!

[Arzar]

Bonjour,

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

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

[Xemame]

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

On doit mettre

Code :

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

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