Héritage avec Template

Bonsoir, je fais du C++ depuis peu et je rencontre un problème

Voici un morceau de ma classe personne

Code:

---

1 2 3 4 5 6 7 8 9 10

class personne { protected: string nom ; string prenom ; public: personne(string _nom, string _prenom): nom(_nom), prenom(_prenom){};   virtual void affiche(){ cout << "mon nom est " << this->getNom() << " et mon prenom " << this->getPrenom() << endl; }

---

avec deux classes (étudiant et professeur) qui hérite de personne

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class etudiant : public personne { private : // donnees specifiques a etudiant string branche; string filiere;   public: etudiant(string _nom, string _prenom, string _branche, string _filiere): personne(_nom, _prenom), branche(_branche), filiere(_filiere){};   void affiche(){ personne::affiche(); cout << "je suis en branche " << this->getBranche() <<" et ma filiere " << this->getFiliere() << endl; }

---

a côté de ça voici mon Template pour créer des Listes

Code:

---

1 2 3 4 5 6 7

template <class T> class liste{   private: T val; liste* reste;

---

que j'utilise pour déclarer une "bdd"

Code:

---

1 2 3 4 5 6 7 8 9 10

class bddPersonnes : public liste<personne> { public:   friend ostream& operator<< (ostream& o, liste<personne>& l){ for(int i=0; i<l.longueur(); ++i){ l[i].affiche() ; } return o; } };

---

et enfin le main

Code:

---

1 2 3 4 5 6 7 8 9

int main(int argc, char *argv) {   etudiant p1("NICOLE", "Antoine", "blabla", "toto"); etudiant p2("TRAPU", "Jean-Phillipe", "titi", "tutu");   bddPersonnes bdd; bdd.inserer(0, p1); bdd.inserer(0, p2); cout << bdd << endl;

---

Le problème se pose enfin, j'ajoute des étudiants dans ma liste bdd, sauf qu'à ce moment la lorsque je fais le "cout << bdd" c'est la méthode affiche() de la classe personne qui est appelée et non pas celle d'étudiant, mais je ne peux pas changer ma liste de personne en liste d'étudiant puisque je voudrais qu'elle contienne à la fois des professeurs et des étudiants ? Comment puis-je faire ?

A priori, c'est ton "inserer" qui est faux.
L'une des raisons, c'est que tu n'utilises pas std::list.

La vraie raison, c'est surtout que les seuls types polymorphiques (s'occupant de virtual) sont les pointeurs et les références.
Or, ta liste est apparemment une liste de personne, pas de personne*.

Code:

---

1 2 3 4 5 6

template <class T> class liste{   private: T val; class bddPersonnes : public liste<personne>

---

T'as beau y insérer des Etudiant, ils seront slicés et copiés en tant que personne puisque ta liste n'accepte que des personnes.
Le polymorphisme nécessite un pointeur ou référence pour utiliser le typage dynamique.
Sinon pourquoi ne pas utiliser std::list ? std::list<std::unique_ptr<Personne> >

Hé bien je voulais essayer les deux, avec les <list> et avec mon template, du coup j'ai "réussi" en passant par une liste<personne*> sauf que ma fonction friend ostream operator<< (de la classe liste<T> ne fonctionne pas car elle n'est pas faite pour fonctionner sur des pointeurs, et que si je redéfinie une ostream operator<< dans la class bddPersonne hé bien j'ai une ambiguïté car les deux auront comme 2nd argument une liste<personne*>. Mais bon ce n'est pas ce qui m'importe je fais des affiche manuel, ce n'était qu'un exercice pour découvrir. Merci

typiquement, tu ne veux pas vraiment d'un ostream << pour une std::list, de quoi que ce soit.
Par contre, tu peux vouloir une fonction qui affiche la classe contenant ta liste.

En règle générale, les classes de la STL sont des détails techniques de ton code, tu peux décider subitement de passer de l'une à l'autre (de list à deque ou à vector, par exemple), sans que cela n'impacte le code métier.

Si tu n'as pas cette classe contenant la liste de métier, c'est que c'est une variable locale, et tu peux très bien écrire toi-même la boucle d'affichage:

Code:

---

1 2 3 4 5

bool first = true; for(auto const& personne_p : personnes) { if (first) first = false; else stream << ", "; stream << *personne_p; }

---

Quand on l'aura, il y a aussi std::experimental::ostream_joiner, qui fera précisément cela.