salut !
Une petite question de base pour vous surement mais qui me turlupine un peu !!!
 
le mot cle virtual, a quoi qu'il sert donc ?
 
z'avez pas une bonne explication car moi y en a pas comprendre son usage.

huhu ... à déclarer des fonctions virtuelles, cad overridables / overloadables par leur classes dérivées, qui peuvent ainsi choisir de changer ou surcharger le comportement des dites fonctions.
 
ie  
 
class A
{
public:
    virtual  MyMethod()  { printf("hello from A" ); }
}
 
class B : public A
{
public:
    virtual  MyMethod()  { printf("hello from B" ); }
}
 
class C : public B
{
public:
    virtual  MyMethod()  { B::MyMethod(); printf("hello from C" ); }
}
 
soit a une instance de A, b une instance de B, c une instance de C
 
a->MyMethod() affiche ("hello from A" );
b->MyMethod() affiche ("hello from B" );
c->MyMethod() affiche ("hello from B", "Hello from C" );
 
une classe dérivée de A peut donc overrider / overloader une méthode de A déclarée comme virtuelle.
 
B->MyMethod() est un override : il change le comportement de la fonction.
C->MyMethod() est un overload : il surcharge la fonction et permet l'apport de nouvelles fonctionnalités.
 
est ce clair ?
 
sachant que tu devrais lire un bouquin sur le c++ & co quand même

OK merci pour tes explications.

en fait ce qui fait l'interret du virtual c'est plutot le polymorphisme:
 
dans l'exemple precedent, ce qu'il y a de rigolo c'est que si t'as par exemple:
 
A *unA=new B(...);
 
unA->myMethod(...);
 
ca vas etre la version de B qui sera appelle
Le mot clef virtual sert au compilo pour rajouter un pointeur sur la methode declare virtual dans la table des fct virtuelles
(vtable)
 
PS: la surcharge c'est pas ce que t'as indique youdontcare, la surcharge c'est quand tu change le prototype de la fonction.

je suis plutot d'accord avec la version de wpk. youdontcare, t'as besoin de declarer les fonctions virtuelles pour faire ce qui tu as fait. Le virtuel, c'est pour le polymorphysme.

OK merci les gars !
vous avez eclaire ma lanterne.

youdontcare -> ta definition override/overload est fausse : ca ne repose pas du tout sur ce qui se passe a l'interieur de la methode, mais bien sur sa signature:
 
L'overloading, c'est par exemple : A::affiche(int) et A::affiche(char) : deux methodes ont le meme nom, mais prennent des arguments de nature differente.
 
L'overriding, c'est par exemple A::affiche(int) et B::affiche(int) : la meme methode est surchargee dans une classe fille.

[edit]--Message édité par Gonzoide--[/edit]

Gonzoide

 
pas surchargée mais redefinie    (c'est juste un point de vocabulaire ton explication sinon est exacte)

oups
 
C'etait juste pour dire que la difference override/overload n'est pas que philosophique, mais repose bien sur des criteres connus a la compilation