Discussion :

[Rodrigue]

Bonjour,

J'ai une classe interface:

Code :

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

1
2
3
4
5
6
class IMemoire
{
public:
   virtual void Insert(int i) = 0;
   //...
};

dont deux autres classes, des implémentations, héritent:

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
class MemoireDisqueDur : public IMemoire
{
public:
   virtual void Insert(int i) { //...}
   //...
private:
   DATAHD data;
};
class MemoireRam : public IMemoire
{
public:
   virtual void Insert(int i) { //...}
   //...
private:
   DATARAM data;
};

Mon problème est que je souhaiterais pouvoir affecter des objets MemoireRam à des objets MemoireDisqueDur:

Code :

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

1
2
3
IMemoire* memram = new MemoireRam;
IMemoire* memHD = new MemoireDisqueDur;
memHD = memRam;

Il faut donc je fasse une conversion de DATARAM vers DATAHD... Comment faire? Il faut que je surcharge l'opérateur = mais comment faire en sorte de ne pas devoir le réécrire pour chaque type de conversion (mettons que j'ai 10 implémentations qui découlent de ma classe IMemoire).

Merci pour votre aide!
Cordialement,
Rodrigue

[Médinoc]

(Attention, ce que tu as mis n'affecte pas les objets, mais les pointeurs)

Tu fais un opérateur d'affectation par classe :

Code :

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

1
2
3
4
MemoireDisqueDur & MemoireDisqueDur::operator= (IMemoire const &src)
{
   //Lire les données à partir de IMemoire pour la conversion
}

[Laurent Gomila]

Plutôt une fonction membre virtuelle, parce que là si tu affectes un IMemoire& à un autre IMemoire&, le compilo aura bien du mal à trouver l'opérateur d'affectation à appeler (qui dépend du type dynamique de l'instance -- d'où la fonction membre virtuelle).

Ensuite tu dois faire ce qu'on appelle du double-dispatch : càd que tu auras aussi besoin de déterminer le type réel du IMemoire à affecter.

Moi ce que je ferais, ce serait créer deux fonctions membres virtuelles dans IMemoire, qui permettent à chaque dérivées d'écrire / lire une même représentation (un buffer de caractères, un stream, ...) afin de faciliter les conversions sans traiter chaque combinaison de types dérivés.

[Rodrigue]

Merci pour vos réponses...

Laurent Gomila> Pas bête du tout, je pense que je vais choisir ta méthode!

[Rodrigue]

Tout fonctionne parfaitement!
Dans mon interface (qui n'en est plus vraiment une maintenant vu que j'ai dû y implémenter une méthode), j'ai déclaré les fonctions virtuelles: Size, GetElement et InsertElement.
De plus, j'y ai surchargé l'opérateur = où j'appelle les fonctions GetElement, InsertElement dans une boucle allant de 0 à Size()-1;

Un grand merci!

[Rodrigue]

J'ai encore un petit problème...

Mettons que mon DATAHD soit en fait un std::vector<.> et que mon DATARAM soit un std::map<.>. Comment feriez-vous pour copier l'un dans l'autre en utilisant si possible des itérateurs qui sont différents:
std::vector<.>::const_iterator
std::map<.>::const_iterator

Note: en fait, j'ai un stxxl::map que je souhaiterais copier dans un std::map (et vice-versa).

Merci encore pour votre aide!

[Rodrigue]

Je suis conscient que je pourrais créer les fonctions GetFirstElement et GetNextElement dans IMemoire pour itérer à travers la structure, tout en insérant les valeurs de retour <index, value> dans mon autre structure mais n'y-a-t'il pas une plus "belle" méthode?