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 !

[Luc Hermitte]

Pour une opération de création de nouvel objet, std::unique_ptr a beaucoup plus de sens. C'est une fonction source.

[mazertys17]

Et si l'objet est destiné à être un shared_ptr ?

[Luc Hermitte]

Ca ne change absolument rien.

[mazertys17]

Ok, merci.

J'ai une autre question, toujours a propos de la copie d'objets :

dois-je recopier systématiquement toutes les variables de l'objet mère dans les constructeurs de copie des objets filles ?
ou existe-t-il une fonction spéciale, comme lors d'une surcharge de fonction :

ex :

Code :

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

1
2
3
4
5
6
 
 
void ObjectHéritéDeObject::fonction()
{
     Object::fonction() ;
}

ceci pourrait-il se faire également dans un constructeur de copie ( afin d'éviter de tout recopier à chaque fois ) :

ex :

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
 
 
ObjectHéritéDeObject::ObjectHéritéDeObject( ObjectHéritéDeObject const& other )
{
 
     Object::Object ( ??! ) ;
     ...
 
    _varriable   = other._varriable ;
    _varriablePtr = new VarriablePtr(  *( other._varriablePtr ) ) ;
 
    etc...
 
 
}
 
ObjectHéritéDeObject ObjectHéritéDeObject::operator = ( ObjectHéritéDeObject const& other )
{
 
     Object::Object ( ??! ) ;
     ...
 
    _varriable   = other._varriable ;
    _varriablePtr = new VarriablePtr(  *( other._varriablePtr ) ) ;
 
    etc...
 
 
    return *this ;
 
}

ou il faut du coup recopier chaque variable pour la copie ?

Merci si vous pouvez m'aider

[Bousk]

Je suis à peu près sûr que dans une construction par copie, le constructeur par copie de la classe mère est automatiquement appelé.
Dans tous les cas, le mieux reste d'utiliser la liste d'initialisation.
Ou réutiliser l'opérateur =

[pascalCH]

Je suis à peu près sûr que dans une construction par copie, le constructeur par copie de la classe mère est automatiquement appelé.

Non, il doit être appelé explicitement.

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
	public  class MaBaseClass
	{
	protected:
		int Numero ;
		int Indice;
	public:
		MaBaseClass()
		{
			this->Numero = 0;
			this->Indice = 0;
		};
 
		MaBaseClass(MaBaseClass & source)
		{
			this->Numero = source.Numero;
			this->Indice = source.Indice;
		}
 
		virtual void Clone(MaBaseClass *target)
		{
			target->Indice = this->Indice;
			target->Numero = this->Numero;
		}
	};
 
	public class MaSuperClasse : MaBaseClass
	{
	protected:
		int Compte;
	public: 
		MaSuperClasse() : MaBaseClass(){ this->Compte = 0; };
		MaSuperClasse(MaSuperClasse & source) : MaBaseClass(source)
		{
			this->Compte = source.Compte;
		}
 
		virtual void Clone(MaSuperClasse *target)
		{
			MaBaseClass::Clone(target);
			target->Compte = this->Compte;
		}
	};

[mazertys17]

En effet, merci !

Qu'en est-t-il de l'operator ?
Doit-on recopier toutes les variables ?

[Luc Hermitte]

Hum... Je sens qu'il y a quelques bases à reprendre.

L'affectation n'est pas compatible (sémantiquement, comme syntaxiquement) avec des hiérarchies. C'est l'un ou l'autre.
En fait, la copie, c'est souvent incompatible avec des hiérarchies. Parfois il arrive que l'on ait vraiment besoin de dupliquer, c'est là que clone() arrive. Mais ... d'abord on voit à concevoir sans cloner(), et si vraiment le besoin apparait, clone() arrivera. Mais seulement à ce moment là. On ne l'introduit pas en avance de phase juste "parce que on ne sait jamais".

A demander comment on fait pour l'affectation plus la question technique sur comment on écrit un constructeur de copie hérité, je soupçonne que tu es en fait dans cette approche : "au cas où on ne sait jamais". La bonne approche "on ne sait jamais" consiste à dire : "on interdit la copie par défaut, et on verra éventuellement plus tard".

[mazertys17]

correction...ca ne marche pas !

Quand je me contente d'expliciter:

Code :

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

1
2
3
4
5
6
 
 
ObjectFille::ObjectFille ( ObjectFille const& other ) : ObjectMere ( other )
{
    _NouvelleVariable = other._NouvelleVariable ;
}

Il ne me copie pas l'objet (ou du moins aucune varriables) . Alors que si je recopie toutes les variables de l'ObjetMere, ca marche...

Enfin j'ai l'impression qu'il y a des objets ou ca marche, et d'autres pas...

[jblecanard]

L'affectation n'est pas compatible (sémantiquement, comme syntaxiquement) avec des hiérarchies. C'est l'un ou l'autre.

Entièrement d'accord. Espérons que oodini ne passe pas par là pour nous tenter de nous démontrer le contraire

Enfin j'ai l'impression qu'il y a des objets ou ca marche, et d'autres pas...

On peut pas t'aider sur des faits imprécis. Je soupçonne que tu as plusieurs niveaux de hiérarchies et que tu as commis une erreur en appelant explicitement le constructeur d'une classe qui n'est pas le parent direct de celle qui pose un problème.

[pascalCH]

Je soupçonne que tu as plusieurs niveaux de hiérarchies et que tu as commis une erreur en appelant explicitement le constructeur d'une classe qui n'est pas le parent direct de celle qui pose un problème.

Effectivement, c'est une petite erreur souvent faite (surtout en C++, les formations utilisant trop les Java, C# qui font perdent beaucoup de sens) , dans le feu de l'action, on oublie quelques principes de bases concernant la durée de vie des objets à savoir :

- avoir un constructeur copie explicite pour chaque classe genre : MaClasse::MaClasse(const MaClass & source) qui appelle, dans l'ordre le ou les constructeurs copies des classes de base.
- avoir un constructeur vide (cTor par défaut) avec la visibilité qui va bien ( généralement protected - public )
- un destructeur qui gère l afin de vie.

Ces petites règles d’hygiène de base permettent de gérer à peu près correctement la vie des objets et de contourner le système de gestion automatique (copie superficielle d'objet par exemple) qui amène des bugs parfois inextricables.

[Luc Hermitte]

Comme tu le dis Pascal, on perd vite certains fondamentaux suivant notre parcours. Mais allons encore plus loin : on a rarement besoin de la copie, en particulier quand nous sommes en présence d'entité, et une hiérarchie polymorphe est un signe fort de sémantique d'entité. La Forme Canonique Orthodoxe de Coplien que tu évoques s'applique aux classes à sémantique de valeur. Cf la FAQ.

[pascalCH]

Comme tu le dis Pascal, on perd vite certains fondamentaux suivant notre parcours. Mais allons encore plus loin : on a rarement besoin de la copie, en particulier quand nous sommes en présence d'entité, et une hiérarchie polymorphe est un signe fort de sémantique d'entité. La Forme Canonique Orthodoxe de Coplien que tu évoques s'applique aux classes à sémantique de valeur. Cf la FAQ.

Sourire, je pense que si mazertys17 consulte le fil de discussion, il va finir par prendre peur !!

Ceci dit, je suis tout à fait d'accord avec toi sur la différence de traitement infligeable à telle ou telle classe en fonction de sa destination; cependant, autant le clonage me semble à utiliser avec précaution uniquement quand la nécessité existe, autant le constructeur copie s'avère à implémentation plus systématique (le compilateur lui même en fabriquant un de toutes pièces si nécessaire et ma confiance dans les automatismes étant plus que relative).