Héritage (pattern Composite)

Bonjour,

J'ai utilisé le design pattern composite pour me créer des classes qui parcourt des fichiers et répertoires. Cependant, dans une fonction héritée du composite, je n'arrive pas à accéder à un attribut. Voici le schéma :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

class Composant { protected: const char* _root; /**< Le path ABSOLU du composant */   public: virtual const char* getPath() = 0; virtual void searchContent() = 0; };   class Repertoire: public Composant { //Le composite protected: vector<Composant*> _contient; /**< Un tableau des composants */   public: Repertoire(const char* root); virtual ~Repertoire();   virtual const char* getPath(); virtual void searchContent(); };

---

La fonction héritée du composite :

Code:

---

1 2 3 4 5 6 7 8 9

class RepTraining: public Repertoire { //hérite du composite public: RepTraining(const char* root); virtual ~RepTraining();   const char* getNameSubdirectory(int index); virtual void searchContent(); virtual const char* getPath(); };

---

Dans ma fonction getNameSubdirectory, je veux accéder au n-ième élément du vector composite, récupérer son chemin (_root) et après modifications, le renvoyer.
Cependant, il me renvoit toujours un mauvais chemin (qui ressemble plus au _root de RepTraining qu'aux répertoires qu'il contient...

Code:

---

1 2 3 4 5 6 7

const char* RepTraining::getNameSubdirectory(int index) { Repertoire* test = static_cast<Repertoire*>(_contient.at(index)); std::string truncateName = test->getPath(); //PAS BON   ..... }

---

Je n'ai pas encore compris toutes les subtilités de l'héritage, et je ne vois pas du tout mon erreur...
Merci d'avance :)

Ben faudrait voir comme est rempli le vecteur.

La fonction searchContent définie dans RepTraining le fait (elle recherche tous les sous-répertoires seulement) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

void RepTraining::searchContent() { DIR* repertoire = opendir(_root); std::string absolute = _root; struct dirent* f = NULL; if(repertoire == NULL) { std::cerr << "Ne peut pas ouvrir le répertoire " << _root << std::endl; return; } while((f = readdir(repertoire)) != NULL) { if(isalnum(f->d_name[0])) { if(absolute.find_last_of("/\\") == absolute.length()-1) { absolute.append(f->d_name); } else absolute.append("/").append(f->d_name); size_t last_point = absolute.find_last_of("."); if(last_point > absolute.length()) { _contient.push_back(new Repertoire(absolute.c_str())); } absolute.erase(strlen(_root),absolute.length()); } } closedir(repertoire); }

---

Cela a mieux fonctionné avec l'utilisation de string à la place de const char*

Citation:

---

Envoyé par Ploupi

Dans ma fonction getNameSubdirectory, je veux accéder au n-ième élément du vector composite, récupérer son chemin (_root) et après modifications, le renvoyer.
Cependant, il me renvoit toujours un mauvais chemin (qui ressemble plus au _root de RepTraining qu'aux répertoires qu'il contient...

Code:

---

1 2 3 4 5 6 7 8 9

const char* RepTraining::getNameSubdirectory(int index) { <s>Repertoire* test = static_cast<Repertoire*>(_contient.at(index));</s> Repertoire* test = dynamic_cast<Repertoire*>(_contient[index]); if (test) std::string truncateName = test->getPath(); //PAS BON   ..... }

---

Je n'ai pas encore compris toutes les subtilités de l'héritage, et je ne vois pas du tout mon erreur...
Merci d'avance :)

---

Ne jamais utiliser static_cast<> pour transtyper une variable du type B vers une variable du type A héritant de B. Si la variable du type B est en fait une variable du type C qui hérite lui aussi de B, tu va avoir des problèmes.

Il faut utiliser dynamic_cast<> pour faire celà, avec deux points à se rappeler :

Code:

---

1 2 3 4 5 6 7 8 9

class B { ... }; class A : public B { ... };   B& b1; A& a1 = dynamic_cast<A&>(b1);   B *b2; A *a2 = dynamic_cast<A*>(&b2);

---

1. Si b1, qui est une référence de type B&, ne référence pas un objet de type A ou d'un type dérivé de A, alors la ligne 6 va générer une exception.
2. Si b2, qui est un pointeur de type B*, ne pointe pas vers une instance de type A ou d'un type dérivé de A, alors a2 == NULL et aucune exception n'est générée (ligne 9)

L'utilisation de dynamic_cast<> n'est possible que sur des types dit polymorphiques, c'est à dire définissant au moins une fonctions virtuelle (sachant que lorsque tu dérive une classe d'une autre, il est de bon ton de spécifier que le destructeur de la classe de base est virtuel). Sur certains compilateurs, il faut activer l'option permettant l'utilisation du RTTI (les compilateurs récents le font pour toi), sans quoi dynamic_cast<> pourrait ne pas générer le code adéquat.