Discussion :

[mazertys17]

Bonjour.

J'essaye de copier des objets hérités, mais il semble que l'héritage ne soit pas pris en compte.
J'utilise pourtant que des fonctions virtuelles dans l'objet mère, et transfère l'objet en std::shared_ptr <Objet>.

Voici un bout de code , où "_object_container" contient des objets "Object_HUD", hérités de l'objet mère "Object" :
(j'aurais pus utilisé un froncteur pour chercher dirrectement l'objet par son nom, mais pour l'instant, c'est pas la question)

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
 
 
 
    std::shared_ptr < Object > model_Object ;
 
    for ( std::vector < std::shared_ptr < Object > > :: iterator it = _object_container.begin() ; it != _object_container.end() ; it ++ )
    {
        if( (*it) -> setName() == name )
        {
 
            model_Object = *it ;
 
        }
 
    }
 
    std::vector < std::shared_ptr < Object > > :: iterator it ;
 
    it = find ( _object_container.begin() , _object_container.end() , model_Object ) ;
 
    std::shared_ptr < Object > model ( new Object ( **it )) ;
 
    model -> getPosition ( x , y ) ;
 
    _object_container.push_back ( model ) ;

L'objet est bien copié, mais en tant qu'Object, et non "Object_HUD"...

Comme je le disais plus haut, l'objet mère ne contient que des fonctions virtuelles, et l'objet est copié en shared_ptr ...Il me semble donc respecter les condition pour effectuer une copie d'objet hérité...

est-ce donc bien le cas ou j'ai oublié quelque chose / ou ca ne marche pas comme ca avec la copie des objets hérités.

Merci si vous pouvez m'aider.

[ternel]

Pour copier virtuellement, il faut "copier virtuellement".
Pour ce faire, on utilise une fonction virtuelle qui copie l'objet, généralement nommée clone().

Par exemple:

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
class Bidule {
public:
    virtual Bidule clone() const {return Bidule();}
};
 
class SuperBidule : public Bidule {
private:
    int i;
public:
    SuperBidule(int a) : i(a) {}
    SuperBidule(SuperBidule const& other) : i(other.i) {}
    SuperBidule operator=(SuperBidule const& other) { i = other.i; return *this;}
 
    virtual SuperBidule clone() const {return *this;}
};

[mazertys17]

Merci pour votre réponse.

Cela me semble être en effet la bonne solution, cependant, quand je tape ce code, il me dit :

"error: invalid covariant return type for 'virtual Object_HUD Object_HUD::clone() const'
"error: overriding 'vitrtual Object Object::clone() const'

voici mes 2 objets :

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
 
class Object
{
 
public :
 
    Object ( ) ;
    ~Object ( ) ;
 
    virtual Object clone() const { return Object() ; }
    ...
 
protected :
 
    ...
};
 
class Object_HUD : public Object
{
 
public :
 
 
    Object_HUD(){}
    Object_HUD( Object_HUD const& other ){}
    Object_HUD operator = ( Object_HUD const& other ) { return *this ; }
 
    Object_HUD clone() const { return *this ; }
 
protected:
 
    ...
};

Ais-je oublié quelque chose ?

[Flob90]

Les retours covariants c'est avec des pointeurs ou des références.

Passes tes opérateurs de copie en protégé et utilises unique_ptr<Object> :

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
 
struct Object
{
  virtual std::unique_ptr<Object> clone() const 
  { return std::make_unique<Object>(*this) ; }
  virtual ~Object() {}
 
protected :
  Object(Object const & rhs)
  { /*stuff*/ }
};
 
struct Object_HUD : Object
{
  std::unique_ptr<Object> clone() const 
  { return std::make_unique<Object_HUD>(*this); }
 
protected:
  Object_HUD(Object_HUD const & rhs)
  { /*stuff*/ }
};

[ternel]

Merci pour la correction.
Ca fait longtemps que je n'avais plus écrit un clone...

[Luc Hermitte]

En passant par des fonctions libres, il y a moyen d'émuler des retours covariants tout en renvoyant des pointeurs intelligents. Cf ce très récent article qui détaille la démarche: http://cppcodereviewers.com/covarian...mart-pointers/

[mazertys17]

Oui, ca marche ! ( j'ai plutôt utilisé un std::shared_ptr <Object> dans mon cas, mais le resultat est le même )

Merci pour vos réponses !