Discussion :

[allserv]

Bonsoir,

Mon problème est tout bête, j'ai une super-classe qui ne peut être instanciée directement. J'ai deux sous classes et en fait je souhaiterais faire une copie de l'instance que je manipule.

Le problème c'est que je ne sais pas quelle classe a été instanciée.
Dois-je me débrouiller avec un dynamic_cast et testé si le pointeur est null ou y 'a une autre solution ?

Merci d'avance

[Pacorabanix]

puisque la copie dépend de la sous-classe, pourquoi ne pas en faire une fonction virtuelle ? Ou alors au pire, si ça ne colle pas avec ce que tu veux faire, faire une fonction virtuelle qui retournerai le "type" de sous classe (sous forme d'enumération par ex. ) ?

[allserv]

Une methode virtuelle qui servirait à faire quoi ?
Je vais t'avouer que je comprends pas trop là

Pour une fonction qui renvoi le type de classe j'y avais déjà songé mais je trouve vraiment pas cela propre, c'est dommage qu'il n'existe pas ce genre de methode sous c++.

Merci encore

[Pacorabanix]

Une methode virtuelle qui servirait à faire quoi ?
Je vais t'avouer que je comprends pas trop là

quelque chose comme

Code :

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

1
2
3
class ClasseMere {
   virtual ClassMere * copie() const = 0;
}

avec implantations pour chacune de tes sous classes... Par contre elle devront renvoyer en principe un pointeur classe de base (donc faire un cast dans la méthose copie() avant le return ). Tu auras donc une vraie copie de ton objet, mais toujours pas d'info sur son type dans le main.

c'est dommage qu'il n'existe pas ce genre de methode sous c++.

Attention, je ne suis pas un professionel et ce n'est pas parceque je te propose quelques solutions qu'il n'y en a pas de bien meilleures . C'est pour te donner des possibilités en attendant éventuellement le conseil de plus avisé que moi.

[JolyLoic]

quelque chose comme

class ClasseMere {
virtual ClassMere * copie() const = 0;
}

avec implantations pour chacune de tes sous classes... Par contre elle devront renvoyer en principe un pointeur classe de base (donc faire un cast dans la méthose copie() avant le return ). Tu auras donc une vraie copie de ton objet, mais toujours pas d'info sur son type dans le main.

C'est un idiome courant, souvent nommé "constructeur de copie virtuel". En anglais, le nom classique pour ce genre de fonction est clone.

Par contre, quelques petites erreurs dans le texte :
- Pas besoin de faire un cast : Un pointeur sur classe fille est implicitement convertible en pointeur sur classe mère, c'est la base du polymorphisme en C++ quand même...
- Il est possible de retourner dans la classe fille un pointeur sur la classe fille. Ca s'appelle "covariant return type". Ca ne sert à rien pour quelqu'un qui ne connait l'objet que par un pointeur sur la classe mère, et qui du coup n'a accès qu'à l'interface présentée par celle-ci, mais quelqu'un qui connaitrait directement l'objet par l'intermédiaire de la classe fille pourrait utiliser cette information supplémentaire.

[Pacorabanix]

- Il est possible de retourner dans la classe fille un pointeur sur la classe fille. Ca s'appelle "covariant return type". Ca ne sert à rien pour quelqu'un qui ne connait l'objet que par un pointeur sur la classe mère, et qui du coup n'a accès qu'à l'interface présentée par celle-ci, mais quelqu'un qui connaitrait directement l'objet par l'intermédiaire de la classe fille pourrait utiliser cette information supplémentaire.

je me disais bien avoir vu ça dans les forums ici, mais je voulais pas le dire de peur de dire une bêtise

- Pas besoin de faire un cast : Un pointeur sur classe fille est implicitement convertible en pointeur sur classe mère, c'est la base du polymorphisme en C++ quand même...

Ah ben j'en ai quand même dit une ^^

[neonico]

Bonjour,
et donc comment caster proprement sur cet 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
16
17
18
19
20
class Mere{
...
   virtual Mere *copy() = 0;

}

class Fille : public Mere{
...
   Mere *copy();

}

CModuleDlg::CModuleDlg(Mere * myMere){

// ca ne link pas ici...
Fille *myFille = (Fille *)myMere->copy();
//comme ici
Fille *myFille = dynamic_cast<Fille *>(myMere->copy());

}

Merci

[Médinoc]

Que veux-tu dire par "ça link pas" ?

[koala01]

Salut,

On a dit: pas besoin de cast, et encore moins de cast sauvage "C style"...

L'idée est d'avoir un code proche de

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
class Mere
{
    public:
        virtual Mere* clone() const = 0;
};
class Fille:public Mere
{
    public:
        virtual Fille * clone() const;
};
class AutreFille: public Mere
{
    public:
        virtual AutreFille * clone() const;
};
Fille * Fille::clone() const
{
    return new Fille;
}
AutreFille * AutreFille::clone() const
{
    return new AutreFille;
}

Mais, attention...

Bien que l'objet soit réellement une nouvelle instance du type dérivé d'origine, tu ne peux être sur de son type que si tu sais, à la base quel était le type réel de la variable d'origine.

Cela signifie que, si tu as

Code :

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

1
2
3
 
Fille * ptr=new Fille;
AutreFille * autrePtr = new AutreFille;

tu aura la certitude d'obtenir une nouvelle instance de Fille en appelant ptr->clone() et une nouvelle instance de AutreFille en appelant autrePtr->clone().

Par contre, si les pointeurs sont considérés comme étant du type de base (Mere, dans le cas présent), par exemple parce qu'ils font partie d'une collection sous une forme proche de

Code :

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

1
2
std::vector<Merer *> ptrTab;
ptrTab.push_back(new Fille);

ptrTab.push_back(new AutreFille);
il est préférable de ne considérer l'instance renvoyée par clone() que comme étant... de type Mere (ou de s'assurer du type réel) car c'est la seule interface dont nous soyons sur de disposer:

Code :

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

1
2
3
4
5
for(size_t i=0;i<ptrTab.size();++i)
{
    Mere* copie=ptrTab[i]->clone();
    /* utilisation de l'interface propre à la classe Mere */
}

En effet, le code suivant "foirera" pour le deuxième élément du tableau (car le deuxième élément est de type ... AutreFille):

Code :

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

1
2
3
4
5
for(size_t i=0;i<prtTab.size(); ++i)
{
    Fille * copie = ptrTab[i]->clone();
    /* utilisation de l'interface propre à Fille */
}

Si tu dois appeler du code particulier à ta classe dérivée, bien qu'il y ait sans doute un problème de conception là derrière, il faut t'assurer de travailler avec le bon type réel:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for(size_t i=0;i<prtTab.size(); ++i)
{
    Mere * copie = ptrTab[i]->clone();
    Fille * cfille = NULL;
    AutreFille * cautrefille = NULL;
    if(cfille=dynamic_cast<Fille*>(copie))
    {
        /* on peut travailler avec cfille  */
    }
    if(cautrefille = dynamic_cast<AutreFille*>(copie) )
    {
        /* on peut travailler avec cautrefille */
    }
}