Polymorphisme et surcharge d'opérateur

Bonjour à tous.
Probleme de polymorphisme, je vais pété un plomb

Question : comment obtenir = Fils à l'étape 4 5 7 8 sans caster.

Execution

------------ Etape 01 ------------
Creation Pere
------------ Etape 02 ------------
Creation Pere
Creation Fils
------------ Etape 03 ------------
------------ Etape 04 ------------
= Pere
------------ Etape 05 ------------
= Pere
------------ Etape 06 ------------
Creation Pere
Creation Fils
------------ Etape 07 ------------
= Pere
------------ Etape 08 ------------
= Pere
------------ Etape 09 ------------
Do Fils
------------ Etape 10 ------------
Creation Pere
Creation Fils
------------ Etape 11 ------------
Creation Pere
Creation Fils
------------ Etape 12 ------------
= Fils
------------ Etape 98 ------------
Destruction Pere
------------ Etape 99 ------------
Destruction Fils
Destruction Pere
Appuyez sur une touche pour continuer...

Code :

#include <iostream>
using namespace std;

/* *************************************************** */

class Pere
{
public:
  Pere::Pere()            {cout << "Creation Pere" << endl;}
  virtual Pere::~Pere()   {cout << "Destruction Pere" << endl;}
  virtual void Pere::Do() {cout << "Do Pere" << endl;}
  virtual Pere & operator = (const Pere & source)   {cout << "= Pere" << endl; return *this;}
};

/* *************************************************** */

class Fils : public Pere
{
public:
  Fils()        {cout << "Creation Fils" << endl;}
  ~Fils()       {cout << "Destruction Fils" << endl;}
  void Do()     {cout << "Do Fils" << endl;}
  virtual Fils & operator = (const Fils & source) {cout << "= Fils" << endl; return *this;}
};

/* *************************************************** */

int main(int argc, char *argv[])
{
  Pere * Tab[2];
  cout << "------------ Etape 01 ------------" << endl;
  Tab[0] = new Pere;
  cout << "------------ Etape 02 ------------" << endl;
  Tab[1] = new Fils;
  cout << "------------ Etape 03 ------------" << endl;
  Fils * F1;
  cout << "------------ Etape 04 ------------" << endl;
  * Tab[1] = * F1;
  cout << "------------ Etape 05 ------------" << endl;
  Tab[1]->operator=(*F1);
  cout << "------------ Etape 06 ------------" << endl;
  Fils  F2;
  cout << "------------ Etape 07 ------------" << endl;
  * Tab[1] = F2;
  cout << "------------ Etape 08 ------------" << endl;
  Tab[1]->operator=(F2);
  cout << "------------ Etape 09 ------------" << endl;
  Tab[1]->Do();
  cout << "------------ Etape 10 ------------" << endl;
  Fils  F3;
  cout << "------------ Etape 11 ------------" << endl;
  Fils  F4;
  cout << "------------ Etape 12 ------------" << endl;
  F3 = F4;

  cout << "------------ Etape 98 ------------" << endl;
  delete Tab[0];
  cout << "------------ Etape 99 ------------" << endl;
  delete Tab[1];

  system("PAUSE");
  return 1;
}

2 trucs que je vois :
- Fils * F1;
  cout << "------------ Etape 04 ------------" << endl;
  * Tab[1] = * F1;
=> F1 n'est jamais crée, il faut faire Fils * F1 = new Fils.

- ton operateur = pour les fils ne sera jamais appelé par un pointeur sur Pere car elles ont beau être virtuelles ce ne sont pas les même (les arguments ne sont pas les même)
=> mettre dans le fils
virtual Pere & operator = (const Pere & source) {cout << "= Fils" << endl; return *this;}
pour réalisre une surcharge correcte.

Tu as raison pour :
Fils * F1 = new Fils;

Mais je ne comprends cette phrase :

ton operateur = pour les fils ne sera jamais appelé par un pointeur sur Pere car elles ont beau être virtuelles ce ne sont pas les même (les arguments ne sont pas les même)


=> mettre dans le fils
virtual Pere & operator = (const Pere & source) {cout << "= Fils" << endl; return *this;}

Si je mets ca, un fils devient pere ?

C'est pas mieux ca dans fils :

virtual Fils & operator = (const Pere & source) {cout << "= Fils" << endl; return *this;}

Si ca marche tu peux. sinon un fils est un père de toute façon.

Par contre je sais pas si faire un operateur = virtuel est une bonne idée, car normalement c'est pour manipuler des objets de même nature (à gauche et à droite) sans passer par des pointeurs. Ca n'a pas beaucoup de sens de faire une copie en profondeur d'un fils vers un père.

  Pere * Tab[2];
  Tab[1] = new Fils;
  Fils * F1 = new Fils;
  * Tab[1] = * F1;

Ici normalement * Tab[1] et * F1 sont tout deux des fils. Si j'utilise :
virtual Fils & operator = (const Pere & source) {... return *this;}
Je ne peux recopier les variables de la classe Fils, seulement celles de la classe pere.

C'est assez bizzare l'utilisation que tu veux faire. si tu veux mettre un nouveaux fils dans le tableau c'est plutot comme cela qu'il faut faire :
Tab[1] = new Fils(F1);
Après avoir bien sur fait un constructeur adequate.

Moi ca ma l'air naturel et ce que tu me donnes n'est pas du polymorphisme