constructeur de copie et heritage

20 octobre 2007 à 11:27:49

Bonjour voila dans mon programme j'ai trois classes vehicule velo et type de velo voici donc le code de leur fichier respectif. Ma question est la suivante comment coder le constructeur de copy de la class velo ? comment faire pour que un velo(v2) récupère la marque,le modele,le nbvitesse et le type.... d'un velo(v1) ?
vehicule.h

#ifndef vehicule_h
#define vehicule_h
class vehicule
{
protected :
//propriété
long id_vehicule;
long nbplace;
string marque;
string modele;
string couleur;
//méthode
vehicule();
vehicule(long,long,string,string,string);
vehicule(const vehicule&);
void affiche();
};
#endif

vehicule.cpp:

#include<iostream>
using namespace std;
#include "vehicule.h"
vehicule::vehicule()
{
id_vehicule=0;
nbplace=0;
marque="";
modele="";
couleur="";
}
vehicule::vehicule(long pid_vehicule,long p_nbplace,
string p_marque,string p_modele,string p_couleur)
{
id_vehicule=pid_vehicule;
nbplace=p_nbplace;
marque=p_marque;
modele=p_modele;
couleur=p_couleur;
}
vehicule::vehicule(const vehicule &copy_vehicule)
{
id_vehicule=copy_vehicule.id_vehicule;
nbplace=copy_vehicule.nbplace;
marque=copy_vehicule.marque;
modele=copy_vehicule.modele;
couleur=copy_vehicule.couleur;
}
void vehicule::affiche()
{
cout<<"id du vehicule : "<<id_vehicule<<endl;
cout<<"nbplace du vehicule : "<<nbplace<<endl;
cout<<"marque du vehicule : "<<marque<<endl;
cout<<"modele du vehicule : "<<modele<<endl;
cout<<"couleur du vehicule : "<<couleur<<endl;
}

typevelo.h:

#ifndef typevelo_h
#define typevelo_h
class typevelo
{
private :
string lib;
public :
typevelo();
typevelo(string);
typevelo(const typevelo&);
void affiche();
};
#endif

typevelo.cpp:

#include<iostream>
using namespace std;
#include "typevelo.h"
typevelo::typevelo()
{
lib="";
}
typevelo::typevelo(string plib)
{
lib=plib;
}
typevelo::typevelo(const typevelo &copy_typevelo)
{
lib=copy_typevelo.lib;
}
void typevelo::affiche()
{
cout<<"type de velo : "<<lib<<endl;
}

velo.h :

#ifndef velo_h
#define velo_h
#include "typevelo.h"
#include "vehicule.h"
class velo : public vehicule
{//velo herite de vehicule donc attention pour
//le constructeur ne pas oublier les propriétés de véhicule
private :
long nbvitesse;
typevelo *pt_typevelo;
public :
velo();
velo(long,long,long,string,string,string,string);
velo(const velo&);
void affiche();
};
#endif

velo.cpp :

#include<iostream>
using namespace std;
#include "velo.h"
velo::velo()
:vehicule()
{
nbvitesse=0;
pt_typevelo= new typevelo();
}
velo::velo(long pid_vehicule,long p_nbplace,long p_nbvitesse,
string p_marque,string p_modele,string p_couleur,string p_lib)
:vehicule(pid_vehicule,p_nbplace,p_marque,p_modele,p_couleur)
{
nbvitesse=p_nbvitesse;
pt_typevelo= new typevelo(p_lib);
}
/*Comment faire pour coder ce constructeur de copie ???? *
velo::velo(const velo &copy_velo)
:vehicule(copy_velo.id_vehicule,copy_velo.marque,
copy_velo.modele,copy_velo.couleur,copy_velo.nbplace)
{
nbvitesse=copy_velo.nbvitesse;
pt_typevelo=new typevelo(copy_velo.pt_typevelo);
}*/
void velo::affiche()
{
vehicule::affiche();
pt_typevelo->affiche();
cout<<"nbvitesse du velo : "<<nbvitesse<<endl;
}

lmghs

20 octobre 2007 à 12:20:04

Quand tous les attributs de tes classes sont copiables, tes classes le deviennent (copiables) implictement sans que tu n'aies rien à faire.

Bémol, dans le cas de hiérarchies d'objets polymorphes,
- soit la copie de sert à rien (et donc il faut l'interdire avec l'affectation),
- soit il faut recourrir à une feinte qui clone les objets (-> FAQ C++ de developpez)

Autrement, il suffit d'appeler le constructeur de copie parent depuis la liste d'initialisation.

class Parent {
protected:
Parent(Parent const& rhs)
: m_truc_qui_nest_pas_copiable(rhs.m_truc_qui_nest_pas_copiable.duplique())
, m_truc_copiable(rhs.m_truc_copiable)
{}
public:
virtual Enfant * clone() const = 0;
private:
TypePasCopiableMaisDuplicable m_truc_qui_nest_pas_copiable;
TypeCopiable m_truc_copiable;
private: // affectation incompatble avec héritage => interdiction
Parent & operator=(Parent const& rhs);
};
class Enfant : public Parent
{
protected:
Enfant(Enfant const& rhs)
: Parent(rhs)
, m_nouveau_champ(rhs.m_nouveau_champ)
{}
public:
virtual Parent * clone() const { return new Enfant(*this); }
private:
AutreTypeCopiable m_nouveau_champ;
};

EDIT: retour covariant
EDIT2: j'ai cliqué par mégarde sur "alerter les modérateurs. Désolé si cela vous notifie directement :("