Pourquoi ne peut-on pas surcharger des méthodes virtuelles dans un héritage ?
Exemple :
class A
{ virtual int f( int ); };
 
class B : public A
{ virtual int f( float ); };
 
class C : public B
{ virtual int f( char ); };
 
Le compilo refuse de compiler mais ça marche si je m'arrête à la classe B. Il parle de méthodes qui risquent d'être cachées.

Bon ca fait un bail que je n'ai plus fait de C++, donc mes explications risques d'etre un peu foireuses
 
1) dans ton code je vois que tu as defini des fonctions virtuelles mais ce sont des donnees en private quand tu ne declare pas explicitement (par default). Donc a la base, tu devrais mettre :
class A
{
public :
  /* toutes les methodes qui accedent
 constructeur
 destructeur
 ... etc */
 virtual int f(int);
private:
 // toutes tes donnees privees
};
Je crois que tu ne dois avoir de fonctions virtuelles que dans tes methodes en public (je suis pas sur)
 
Il y a peut- etre une histoire que tu dois mettre ta methode-acceseur de la classe A en virtuel pure
genre virtual int f = 0; (franchement pas sur non plus )
 
Un bon conseil cependant : achetes toi le bouquin de Bjarne Stroussup "le langage c++" : c'est vraiment complet la-dedans et tu trouveras reponse a toutes tes questions (mais c'est trash a lire).
a+

[jfdsdjhfuetppo]--Message édité par alligator421--[/jfdsdjhfuetppo]

merci de répondre, mais bon c'était un exemple, les méthodes sont en public, de plus en protected c'est très utile aussi ( pour faire une surcharge d'opérateur comme cout << a par exemple )
non ce que je comprends pas, puisque le compilo génère le nom d'une méthode en fonction de son nom et de ses param d'entrées, pourquoi dans la vtable, il remplacer B::f( float ) par C::f( char ) par exemple. Et dans les docs des compilos, tous le font, why ?

y'a pas bcp de sens à surcharger des methodes virtuelles :
les methodes virtuelles servent au mechanisme de polymorphisme qui est particulierement interessant quand les methodes virtuelles portent la meme signature :
 
exemple qui considere que ta methode f a la meme signature ds toutes les classes heritieres de A:
 
 
A *p1 = new A();
A *p2 = new B();
A *p3 = new C();
 
p1->f(5);
p2->f(5);
p3->f(5);
dans tous ces appels, tu indique au compilo quelle methode appeller seulement au moment de l'instanciation d'une des heritieres de A. Tu peux donc utiliser une instance de B en lieu et place d'une instance de A. Si tu t'amuse ensuite de surcharger, le mechanisme du polymorphisme n'a plus de sens (le linkage peut etre fait en statique). Ceci dit meme si tu vire le virtual, le compilo ne surcharge pas vraiemnent ta methode f qd il y a heritage.
Dans B par exemple, faudra mettre:
 
class B : public A
{
  using A::f;
  int f(float);
};
 
 
pour lui indiquer d'utiliser aussi le f de A.
 
(Si t'est sous visual, moi j'ai pas reussi à faire marcher les using donc tu declares simplement une methode
int f(int toto) { A::f(toto); } )

ce n'est pas un probleme de fonctions virtuelles
c'est parce que tu as des fonctions de definition
trop proches!
 
f(3), 3 peut-etre a la fois un int et un char
le compilateur ne sait pas quelle fonction appeler!
 
ce serait la meme chose si tu avais
class A{
  int f(char);
  int f(int);
};
 
A+
LEGREG

 
non non, même avec des objets de types très différents ça passe pas, et pour la surcharge ça peut être utile pour le design pattern visiteur par exemple, pour éviter des visitcontreteA et visitconreteB, et avoir un seul nom de méthode pour la classe visiteur. je sais, au boulot, j'ai du refaire les noms de toutes mes méthodes et les réécrire partout dans le code.
mais bon ce que je voulais c'est la raison théorique qui empêchent de faire ça.