Discussion :

[titibete]

Bonsoir,

J'ai une question qui peut paraître idiote, peut-on écrire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class Base
{
    public :
        virtual void f(){};
}
 
class Derived : public Base
{
    public :
        void f(){ Base::f(); };
}

Dis comme çà, c'est un peu inutile. Le but est en fait d'utiliser f() tel que définit dans Base en ajoutant des fonctionnalités pour Derived.

Merci d'avance.

[burndev]

salut

dans un premier temps tu ne surcharge pas une méthode mais tu la redéfinis
La surcharge correspond a déclarer et définir plusieurs fonctions ayant le même nom, à condition que les listes de leurs arguments diffèrent

avec la redéfinition de la méthode dans ta class dérivé, tu masque celle de la class de base.
l'utilisation de virtual fonctionne dans le cadre du polymorphisme.

et oui effectivement tu peux appeler la méthode de la class de base dans la méthode redéfini de la class dérivé.

Rien ne t'empêche non plus d'appelé la méthode de la class de basse malgré la redéfinition.

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 Base
{
    public :
        virtual void f(){};
}
 
class Derived : public Base
{
    public :
        void f(){ Base::f(); };
}
 
Derived maClass;
maClass.Base::f();

a plus

[titibete]

C'est vrai, ce n'est qu'une redéfinition. Shame on me !

Mais avec le code suivant, c'est une surcharge, non ?

Pour mieux comprendre le but :

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
 
class Base
{
    public :          // en "protected :" ça paraît plus compliqué !
        int i;
 
    public :
        virtual void f(){};
}
 
class Derived : public Base
{
    public :
        void f(const int val);
}
 
void Derived::f(const int val)
{
    Base::f();
    i = val;
}

Je peux donc écrire :

Code :

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

1
2
3
4
5
 
Derived maClass;
Base* instanceDerived = &maClass;
 
instanceDerived->f(0);

[koala01]

Salut,

C'est vrai, ce n'est qu'une redéfinition. Shame on me !

Mais avec le code suivant, c'est une surcharge, non ?

Pour mieux comprendre le but :

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
 
class Base
{
    protected :
        int i;
 
    public :
        virtual void f(){};
}
 
class Derived : public Base
{
    public :
        void f(const int val);
}
 
void Derived::f(const int val)
{
    Base::f();
    i = val;
}

Là, tu as, effectivement, une surcharge...

Mais attention, ce n'est pas une redéfinition, ce qui fait que si tu écrivait purement et simplement

Code :

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

1
2
3
4
5
void Derived::f(const int val)
{
    f();
    i = val;
}

sans avoir redéfini void f() dans ta classe dérivée, cela reviendrait exactement au même (car f() est une fonction qui est tout à fait accessible depuis Derived, vu qu'elle fait partie de l'interface publique de Base )
par contre,

Je peux donc écrire :

Code :

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

1
2
3
4
5
 
Derived maClass;
Base* instanceDerived = &maClass;
 
instanceDerived->f(0);

Hééé non...

La raison est simple: ton pointeur instanceDerived passe pour être... du type Base, et non du type Derived.

Tu ne peux donc invoquer que les fonctions publiques qui font partie de ... l'interface (publique) de Base.

Or, en tant que Base, la seule fonction qui soit connue, c'est celle... ne prenant aucun argument

D'ailleurs, si tu avais essayé de compiler, tu t'en serais aperçu, car il t'aurais "jeté" à coup de "fonction f(int) non déclarée dans Base" (ou message similaire )

Au final: avec tes classes Base et Derived telles que tu les as présentées, tu en arrive aux situations suivantes:

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
int main()
{
    Derived deriv;
 
    deriv.f(); // appelle Base::f(), car elle n'a pas été redéfinie pour Derived
 
    deriv.f(5); // appelle Derived::f(int)
 
    Base & b=deriv; // ca marche aussi avec les références :D
 
    b.f(); // OK : b passe pour être du type Base
 
    b.f(10); // KO : b passe pour être du type Base qui ne déclare pas
             // de fonction f(int)
 
    return 0;
}

EDIT: Il faut noter que, si une fonction est déclarée virtuelle dans la classe de base et redéfinie dans la classe dérivée sans avoir été déclarée virtuelle, la redéfinition dans la classe dérivée sera néanmoins réputée virtuelle.

Si tu invoque la fonction redéfinie au départ d'un objet dont le type réel est la classe dérivée mais passant pour être du type de la classe de base, tu observera effectivement le comportement polymorphe, car ce sera bel et bien la version de la classe dérivée qui sera utilisée.

Par contre, si la fonction n'est pas déclarée virtuelle dans la classe de base, et qu'elle est redéfinie dans la classe dérivée, la redéfinition cachera simplement l'implémentation de la classe de base.

Cela signifie que, si tu invoque la fonction depuis un objet du type de la classe dérivée, ce sera la version de la classe dérivée qui sera utilisée, mais que si tu invoque la fonction depuis un objet dont le type réel est la classe dérivée mais passant pour être un objet du type de la classe de base (référence ou pointeur), ce sera... la version de la classe de base qui sera utilisée, et tu n'observera donc pas le comportement polymorphe

[titibete]

Donc, pour que ça marche, il faudrait que je code :

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
 
class Base
{
    public :         
        int i;
 
        virtual void f(){};
        virtual void f(const int val){};
}
 
class Derived : public Base
{
    public :
        void f(const int val);
}
 
void Derived::f(const int val)
{
    f();
    i = val;
}

C'est çà ?

[burndev]

Donc, pour que ça marche, il faudrait que je code :

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
 
class Base
{
    public :         
        int i;
 
        virtual void f(){};
        virtual void f(const int val){};
}
 
class Derived : public Base
{
    public :
        void f(const int val);
}
 
void Derived::f(const int val)
{
    f();
    i = val;
}

C'est çà ?

tu as exactement la même chose avec en plus la redéfinition de la surcharge f(const int val) et tu masque toujours f() et ces surcharges en base.

Que cherche tu vraiment a faire avec cette exemple.

[koala01]

A peu près, si ce n'est que, dans le cas présent, Base::f (sans argument) n'a pas vraiment d'intérêt à être déclarée virtuelle, vu qu'elle n'est pas redéfinie...

Il faut comprendre que la virtualité a un cout, entre autre, du fait du passage par une table des fonctions virtuelles (la vtable) qui permet, justement, de déterminer quelle fonction appeler effectivement.

L'idée est donc de ne déclarer virtuelles que les fonctions qui ont de bonnes raisons de l'être

Maintenant, nous sommes d'accords sur le fait que je ne fais que répondre à la question "pour que cela marche"...

A coté de cela, je ne me prononce absolument pas sur l'opportunité de faire apparaitre f() ou f(int) dans l'interface de la classe de base... Et encore moins sur l'opportunité de permettre de les redéfinir dans les classes dérivées.

Pour pouvoir se prononcer sur ces opportunité, il faudrait présenter un cas concrêt, avec des classes dont les responsabilités seraient connues et donc dont les services attendus tant par f() que par f(int) seraient clairement identifiés

[gl]

Mais attention, ce n'est pas une redéfinition, ce qui fait que si tu écrivait purement et simplement

Code :

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

1
2
3
4
5
void Derived::f(const int val)
{
    f();
    i = val;
}

sans avoir redéfini void f() dans ta classe dérivée, cela reviendrait exactement au même (car f() est une fonction qui est tout à fait accessible depuis Derived, vu qu'elle fait partie de l'interface publique de Base )

Si ma mémoire ne me joue pas des tours (et u test vite fait tend à le confirmer), non f() ne suffit pas (il faut bel et bien préciser Base::f()) car f() est masqué par f(int) lors du name lookup.

[koala01]

Si ma mémoire ne me joue pas des tours (et u test vite fait tend à le confirmer), non f() ne suffit pas (il faut bel et bien préciser Base::f()) car f() est masqué par f(int) lors du name lookup.

Ah, oui, au temps pour moi...

j'ai parlé un peu vite