Discussion :

[syntaxerror]

Je sui confronté à un petit problème pourtant relativement commun : j'ai créé pour un programme une structure de liste chainée très primaire et j'aimerai lui rajouter des membres de données et des méthodes grâce à l'héritage afin de lui ajouter certaines fonctionnalitées utiles à certains endroits du programme (tout en gardant la classe servant de base car également utilisée).

Ma classe de liste basique s'apparente à ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
class Liste
{
public:
    // Méthodes...
private:
    // Membres de données
    Liste *next;
};

Où next représente un pointeur vers l'élément suivant de la liste bien entendu.

Le problème, étant que lors de la création de ma classe ListeEtendue, par héritage public de liste, le pointeur nommé précédement "next" reste de type Liste et ne prends pas le type ListeEtendue.

Aussi ma question est : existe il une manière académique / ou éprouvée de traiter le problème ?

Certaines personnes m'avaient conseillé d'avoir recours à des fonctions virtuelles avec du cast, mais je trouve que ca complexifie beaucoup la chose pour un problème tout de même très simple (surtout que je préfererai que l'utilisateur puisse utiliser simplement cette classe).

Personnelement j'ai procédé de la sorte :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
// Squellette de base de la liste : aucun n'objet ne sera instancié de cette dernière
template <class T>
class BaseListe
{
    // Membres et méthodes publiques et privées
    T *next;
}
 
// Ma liste basique
class Liste : public BaseListe<Liste>
{
};
 
// Ma liste étendue
class ListeEtendue : public BaseListe<ListeEtendue>
{
    // Méthodes et membres de données supplémentaires
}

( l'héritage "vide" de Liste à partir de BaseListe s'expliquant par l'impossibilité d'avoir recours à un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

class List; typedef BaseList<List> List;

)

Ca marche, mais je me demandai s'il n'existait pas une meilleure solution (simple!). Merci.

[Laurent Gomila]

Next sera de type T, mais après ? Qu'est-ce que les fonctions membres vont renvoyer et prendre en paramètre ? Tu devrais templatiser toute ta classe Liste.

A part ça, habituellement la classe liste n'est pas un noeud. Ca occasionne pas mal de problèmes. Tu devrais déclarer en interne une classe (template aussi) de noeuds et faire en sorte que Liste gère simplemente un pointeur sur le 1er noeud.

Mais sauf si c'est pour un exercice, tu devrais utiliser std::list qui fait déjà tout ça très bien.

[syntaxerror]

Justement BaseList est intégralement templatisé (c'est vrai que je n'ai pas montré les fonctions retournant les "T *" : mais les fonctions comme style GetNext renvoient un "T *".

Sinon pour list de la stl, j'avais jetté un oeil, mais la structure que je désire est très simple et sera instancié d très nombreuses fois : la stl me propose quantité de méthodes (avec les membres de données qui y sont donc associés) qui ne me sont d'aucune utilité et prennent de la place pour rien quand on considère l'ensemble de mes noeuds...

[jmv]

Implémenter une fois dans sa vie une liste chaînée est très instructif, ça permet de mieux comprendre le fonctionnement des listes. Mais si c'est pour faire une application, mieux vaut laisser sa fierté personnelle au vestiaire et utiliser std::list qui est fiable est performante.

la stl me propose quantité de méthodes (avec les membres de données qui y sont donc associés) qui ne me sont d'aucune utilité et prennent de la place pour rien quand on considère l'ensemble de mes noeuds...

Les fonctions que tu n'utilise pas ne sont pas inclues dans l'exécutable. Quant au données membres de std::list, je crois qu'il n'y a que 2 ou 3 pointeurs et un size_t pour la taille.

[jmv]

re
je te propose le code suivant qui peut te servir de base

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>
using namespace std;
 
template <typename T> class BaseListe
{
protected:
	class node
	{
	public:
		node(const T& t, node* n) : val(t), next(n) {}
		T val;
		node* next;
	};
 
	node*  first;
	node*  last;
	size_t size_;
public:
	BaseListe() : first(0), last(0), size_(0) {}
	virtual ~BaseListe() { /* à completer */ }
	//...
};
 
template <typename T> class ListeEtendue : public BaseListe<T>
{
public:
    size_t size() const { return this->size_; }
};
 
int main(int argc, char *argv[])
{
    ListeEtendue<int> l;
    cout << l.size() << endl;
    cin.ignore();
    return EXIT_SUCCESS;
}

[syntaxerror]

Oui effectivement, je suis allé faire un tour dans list.h et les nombre de membres de donnés ne sembe pas trop important (même si le code est difficilement lisible pour moi )

Je pense donc me tourner vers cette solution, merci

[jmv]

Je pense donc me tourner vers cette solution

Sage décision.

au fait: sizeof(list<int>) vaut 8... difficile de faire moins.

[Luc Hermitte]

la stl me propose quantité de méthodes (avec les membres de données qui y sont donc associés) qui ne me sont d'aucune utilité et prennent de la place pour rien quand on considère l'ensemble de mes noeuds...

Les fonctions que tu n'utilises pas ne sont pas inclues dans l'exécutable. Quant au données membres de std::list, je crois qu'il n'y a que 2 ou 3 pointeurs et un size_t pour la taille.

+42!!
En C&C++, on ne paye pas ce que l'on n'utilise pas.

(J'ai coupé le reste de la citation de jmv pour que le mitouillage ne soit pas trop visible, il reste que c'était grandement pertinent)

Sinon, attention à l'héritage de structures comme les listes. L'héritage public est rapidement traitre car il casse vite le LSP (déjà abordé il y a quelques semaines). Exemple typique de mauvais design: dériver publiquement une liste triée à partir d'une liste "simple".