Discussion :

[mathher]

Bonjour,
Je suis nouveau sur le forum et un grand débutant en C++
J'ai néanmoins de bonnes notions de Java

Mon problème est le suivant : j'ai besoin de plusieurs listes contenant des objets qui ne sont pas de type primitif tel que int, char, ....
Exemple : je voudrais un type ListA qui contiendraient des objets de type A
et un type ListB avec des objets B
Pour ce faire je veux faire hériter les classes ListA et ListB de la classe list de la stl. Jusque la je ne pense pas qu'il y ait de problème. Mais je ne vois vraiment pas comment je pourrais faire pour redéfinir les méthodes de list de manière à ce qu'elles prennent des objets A ou B en argument.
Pouvez-vous m'aider? Le message est-il assez clair?

Merci beaucoup

[Fiquet]

Attention ! Les classes conteneurs de la STL ne sont pas faites pour être dérivées.. Mais tu peux mettre n'importe qu'elle type comme paramètre template où est donc le problème ?

Code :

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

std::list<MonTypeDefiniNimporteQuoi> mesObjets;

[mathher]

ben le probleme c'est que je dois rajouter des méthodes sur ces listes

[Fiquet]

Ce n'est pas à ça que servent les conteneurs.. Tu dois avoir un problème de designe ou quelque chose. Pourquoi ajouter des méthodes ? Précise ton problème et on pourra peut-être t'aiguiller.

[superspag]

La STL ne propose que des type template => tu peux utiliser nimporte quel type.

Ex :

Code :

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

1
2
3
4
5
6
7
8
 
typedef std::list<A> ListAType;
...
ListAType maListeDeA;
...
A unObjetA;
maListeDeA.push_back(A);
...

D'un point de vue design, si tu dois ajouter des fonctionalitées il faut le faire à l'exterieur.

Soit avec des fonctions global :

Code :

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

1
2
3
4
 
static void maFonctionSurLesListeDeA(ListAType& list, ...param...) {
...
};

Soit tout encapsulé dans une autre classe :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class maClass {
...
ListAType _unAttributDeMaClasse;
...
void uneMethodeDeMaClasse(... param...) {
// Je fait ici des action sur/avec unAttributDeMaClasse
};
....
};

[JolyLoic]

Bonjour,
Je suis nouveau sur le forum et un grand débutant en C++
J'ai néanmoins de bonnes notions de Java

Si tu connais bien Java, les conteneurs du C++ ressemblent plus aux conteneurs génériques de Java qu'aux conteneurs de base. Créer une List de A ne se fait donc pas du tout par héritage d'une liste de base.

[mathher]

en gros je dois creer un methode qui parcoure la liste et compare les elements avec un element donné et si l'element n'est pas dedans il le rajoute
il faut en plus gerer l'efficacite de la methode en définissant un maniere de trier les elements par ordre croissant suivant un ordre prédéfini

[Matthieu Brucher]

Si tu veux hériter d'une liste de A pour une raison X ou Y, essaie plutôt d'implémenter une liste perso en terme de list<A>.
En gros, tu ferais qqch du genre :

Code :

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

1
2
3
4
5
6
7
8
 
class ListA
{
public:
//Les fontions auxquelles tu veux accéder, celles de la STL plus tes persos
private:
std::list<A> listImpl;
};

Et tu fais tous tes appels sur listImpl qui est l'implémentation de ta liste personnalisée.
Ne pas oublier que les conteneurs standards ne sont absolument pas fait pour être hérités - les destructeurs ne sont pas virtuels -, même si les destructeurs sont déclarés public.

[Pragmateek]

en gros je dois creer un methode qui parcoure la liste et compare les elements avec un element donné

L'opérateur de comparaison doit être définie pour la classe des objets.

par ordre croissant suivant un ordre prédéfini

et les opérateurs de relation d'ordre.

[JolyLoic]

en gros je dois creer un methode qui parcoure la liste et compare les elements avec un element donné et si l'element n'est pas dedans il le rajoute
il faut en plus gerer l'efficacite de la methode en définissant un maniere de trier les elements par ordre croissant suivant un ordre prédéfini

Ce que tu décris ne ressemble pas franchement à une list<A>, mais à un set<A> ou une map<A, ??>.

[Matthieu Brucher]

J'ai aussi l'impression...

[mathher]

je crois que je vais appliquer la méthode de miles

merci a vous
a la prochaine question....

[Rafy]

en gros je dois creer un methode qui parcoure la liste et compare les elements avec un element donné et si l'element n'est pas dedans il le rajoute
il faut en plus gerer l'efficacite de la methode en définissant un maniere de trier les elements par ordre croissant suivant un ordre prédéfini

Il exite alors les set, qui trie les éléments du conteneur suivant leur opérateur <.... tu peux avoir ainsi une 'liste' triée, sans rien faire...
Pour savoir si un élément est dans un conteneur il suffit de faire un find et tu sauras rapidement...
Il faut savoir autre chose :
Tu ne pourra pas faire mieux que la STL (du point de vue de la rapidité) donc si tu recodes ce que fais déjà la STL, alors tu perds du temps pour plusieurs raisons :
-> Tu codes un truc déjà fais
-> Tu risques de réinventer la roue
-> Tu risque de faire moins performant, et moins sur que la STL
Enfin bref, la STL, c'est de la balle, il faut l'utiliser.

[Luc Hermitte]

Autre chose importante. Au delà des considérations techniques telles que :
- tu cherches un conteneur associatif/trié
- les conteneurs de la SL n'ont rien de virtuels et ne sont pas faits être être hérités.

Je vais developper le second point en revenant aux sources OO qui expliquent cette implémentation particulière des conteneurs de la SL.

Si on t'a appris que l'OO c'est bien car on peut hériter d'une classe pour réutiliser du code existant, et donc qu'en Java on peut définir, par héritage, une liste triée à partir d'une simple liste, et bien on t'a menti!

Un point important dans les langages OO à typage fort, c'est que l'héritage est d'abord pour permettre de définir des classes dont les objets peuvent se substituer à des objets parents. Tout en respectant les invariants attendus aux deux niveaux.

Ainsi. Un type liste va supporter une fonction membre "insérer_à_une_position_donnée". Un type liste triée, une fonction membre "insérer" qui insèrera à la position idoine respectant l'invariant "quelques soient les positions i et j, i<j, alors critère_de_tri(i)<critère_de_tri(j)".

Si la liste triée devait être-une liste, alors elle devrait définir les deux fonctions et l'invariant particulier des listes triées. En définissant les deux fonctions, cela voudrait dire qu'une fonction qui ajoute un élément à la fin de la liste devrait toujours pouvoir fonctionner à cause du est-un, la liste triée se doit être substituable à tout représentant de liste.
Seulement, la seule existence de cette fonction met en péril l'invariant de la liste triée.

Une liste triée ne peut pas être-une liste.


Il faut bien voir que "liste" est (dans ce cadre) un détail d'implémentation, une forme d'organisation et de gestion des données.

Ni l'héritage du Java, ni l'héritage public du C++ ne permettent de ne modéliser que la relation "implementé-en-termes-de". L'aspect est-un s'inscruste obligatoirement avec ces héritages.

Dans tous les cas, on peut déléger l'implémentation à un sous objet -- la solution que tu disais vouloir finalement retenir. En C++, on dispose aussi de l'héritage privé qui n'a que faire d'un destucteur virtuel.



PS pour d'autres. Il n'y a rien de choquant à implémenter un conteneur particulièr au dessus d'un conteneur standard, je le fais régulièrement. Cela permet de limiter l'interface au strict minimum qui nous intéresse, voire à rajouter des fonctions de recherche plus fines, ou plus généralement réaliser des traitements plus pointus.