Template & pointeurs

Le
Raph`
Bonjour à tous,

Je suis sur un ptit projet perso que j'aimerais faire de A à Z (sans
utiliser de lib existante, ca peut paraitre bete, mais ca me
motive :)) et je coince sur des templates mélés à des pointeurs

Pour faire simple : j'ai fait une liste chainée générique
(TempList<T>) dans laquelle j'ai une méthode "void find(T &t)" qui se
positionne sur l'élément "t".

Problème : cette méthode utilise bien sur l'opérateur !=. Aucun
problème pour stocker des int, float et autres type de base

En revanches, pour les types pointeurs (tel que char * ou autres
objets complexes) y'a-t-il un autre moyen que d'utiliser la
spécification (étant donner que ca doit être réutilisable, je ne pe=
ux
spécifier chaque type, vu que je ne les connais pas) ?

Pour plus de détail, au cas ou cela ne suffise pas, j'ai une classe
complexe (Node) qui contient en donnée privée un identifiant (unsigned
long) et j'ai surchargé l'opérateur !=, le problème est que je stoc=
k
dans la liste des pointeurs (Node *). Evidement, il compare les
adresse et ne cherche meme pas a acceder à l'opérateur surchargé J=
e
ne veux pas stocker de "Node", pour des raisons de duplication en
mémoire (j'ai plusieurs listes de node et donc des noeuds en double,
triple, voir plus)

Merci d'avance !
Raphaël.
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
David Côme
Le #14591191
On Thu, 10 Jul 2008 17:13:39 +0200, Raph`
Bonjour à tous,

Je suis sur un ptit projet perso que j'aimerais faire de A à Z (sans
utiliser de lib existante, ca peut paraitre bete, mais ca me
motive :)) et je coince sur des templates mélés à des pointeurs...

Pour faire simple : j'ai fait une liste chainée générique
(TempList<T>) dans laquelle j'ai une méthode "void find(T &t)" qui se
positionne sur l'élément "t".

Problème : cette méthode utilise bien sur l'opérateur !=. Aucun
problème pour stocker des int, float et autres type de base...

En revanches, pour les types pointeurs (tel que char * ou autres
objets complexes...) y'a-t-il un autre moyen que d'utiliser la
spécification (étant donner que ca doit être réutilisable, je ne peux
spécifier chaque type, vu que je ne les connais pas) ?

Pour plus de détail, au cas ou cela ne suffise pas, j'ai une classe
complexe (Node) qui contient en donnée privée un identifiant (unsigned
long) et j'ai surchargé l'opérateur !=, le problème est que je stock
dans la liste des pointeurs (Node *). Evidement, il compare les
adresse et ne cherche meme pas a acceder à l'opérateur surchargé... Je
ne veux pas stocker de "Node", pour des raisons de duplication en
mémoire (j'ai plusieurs listes de node et donc des noeuds en double,
triple, voir plus...)

Merci d'avance !
Raphaël.




Spécialisation partielle avec T* ?
pjb
Le #14591181
"Raph`"
Bonjour à tous,

Je suis sur un ptit projet perso que j'aimerais faire de A à Z (sans
utiliser de lib existante, ca peut paraitre bete, mais ca me
motive :)) et je coince sur des templates mélés à des pointeurs...

Pour faire simple : j'ai fait une liste chainée générique
(TempList<T>) dans laquelle j'ai une méthode "void find(T &t)" qui se
positionne sur l'élément "t".

Problème : cette méthode utilise bien sur l'opérateur !=. Aucun
problème pour stocker des int, float et autres type de base...

En revanches, pour les types pointeurs (tel que char * ou autres
objets complexes...) y'a-t-il un autre moyen que d'utiliser la
spécification (étant donner que ca doit être réutilisable, je ne peux
spécifier chaque type, vu que je ne les connais pas) ?

Pour plus de détail, au cas ou cela ne suffise pas, j'ai une classe
complexe (Node) qui contient en donnée privée un identifiant (unsigned
long) et j'ai surchargé l'opérateur !=, le problème est que je stock
dans la liste des pointeurs (Node *). Evidement, il compare les
adresse et ne cherche meme pas a acceder à l'opérateur surchargé... Je
ne veux pas stocker de "Node", pour des raisons de duplication en
mémoire (j'ai plusieurs listes de node et donc des noeuds en double,
triple, voir plus...)



Alors il faut faire une version de find qui travaille avec les pointeurs:

Template <class T> void find(T* t){
... (*element)!=(*t) ...
}

--
__Pascal Bourguignon__
James Kanze
Le #15291821
On Jul 10, 5:35 pm, (Pascal J. Bourguignon)
wrote:
"Raph`"


> Je suis sur un ptit projet perso que j'aimerais faire de A à
> Z (sans utiliser de lib existante, ca peut paraitre bete,
> mais ca me motive :)) et je coince sur des templates mélés à
> des pointeurs...



> Pour faire simple : j'ai fait une liste chainée générique
> (TempList<T>) dans laquelle j'ai une méthode "void find(T
> &t)" qui se positionne sur l'élément "t".



> Problème : cette méthode utilise bien sur l'opérateur !=.
> Aucun problème pour stocker des int, float et autres type de
> base...



> En revanches, pour les types pointeurs (tel que char * ou
> autres objets complexes...) y'a-t-il un autre moyen que
> d'utiliser la spécification (étant donner que ca doit être
> réutilisable, je ne peux spécifier chaque type, vu que je ne
> les connais pas) ?



> Pour plus de détail, au cas ou cela ne suffise pas, j'ai une
> classe complexe (Node) qui contient en donnée privée un
> identifiant (unsigned long) et j'ai surchargé l'opérateur
> !=, le problème est que je stock dans la liste des
> pointeurs (Node *). Evidement, il compare les adresse et ne
> cherche meme pas a acceder à l'opérateur surchargé... Je ne
> veux pas stocker de "Node", pour des raisons de duplication
> en mémoire (j'ai plusieurs listes de node et donc des noeuds
> en double, triple, voir plus...)



Alors il faut faire une version de find qui travaille avec les pointeurs:

Template <class T> void find(T* t){
... (*element)!=(*t) ...
}



C'est une possibilité, mais...

D'abord, je ne vois pas où est le problème avec des pointeurs.
L'égalité (les opérateurs == et !=) sont bien défini sur les
pointeurs, et selon le cas, c'est précisement cette définition
qu'on veut quand on a une collection de pointeurs.

D'autre part, on pourrait bien vouloir y mettre des types pour
lesquels l'égalité n'est pas définie du tout, ou vouloir un
autre critère d'égalité (des flottants à 1E-6 près, par
exemples). Ce qui suggère plutôt un surcharge de la fonction,
avec un paramètre en plus pour définir la fonction de
comparaison.

Et en passant, pourquoi pas std::list et std::find/std::find_if ?
Et à quoi sert une fonction de find qui renvoie void ?

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Raph`
Le #15299741
On 11 juil, 09:35, James Kanze
On Jul 10, 5:35 pm, (Pascal J. Bourguignon)
wrote:



> "Raph`" > > Je suis sur un ptit projet perso que j'aimerais faire de A à
> > Z (sans utiliser de lib existante, ca peut paraitre bete,
> > mais ca me motive :)) et je coince sur des templates mélés à
> > des pointeurs...
> > Pour faire simple : j'ai fait une liste chainée générique
> > (TempList<T>) dans laquelle j'ai une méthode "void find(T
> > &t)" qui se positionne sur l'élément "t".
> > Problème : cette méthode utilise bien sur l'opérateur !=.
> > Aucun problème pour stocker des int, float et autres type de
> > base...
> > En revanches, pour les types pointeurs (tel que char * ou
> > autres objets complexes...) y'a-t-il un autre moyen que
> > d'utiliser la spécification (étant donner que ca doit être
> > réutilisable, je ne peux spécifier chaque type, vu que je ne
> > les connais pas) ?
> > Pour plus de détail, au cas ou cela ne suffise pas, j'ai une
> > classe complexe (Node) qui contient en donnée privée un
> > identifiant (unsigned long) et j'ai surchargé l'opérateur
> > !=, le problème est que je stock dans la liste des
> > pointeurs (Node *). Evidement, il compare les adresse et ne
> > cherche meme pas a acceder à l'opérateur surchargé... Je ne
> > veux pas stocker de "Node", pour des raisons de duplication
> > en mémoire (j'ai plusieurs listes de node et donc des noeuds
> > en double, triple, voir plus...)
> Alors il faut faire une version de find qui travaille avec les pointeur s:

> Template <class T> void find(T* t){
> ... (*element)!=(*t) ...
> }

C'est une possibilité, mais...

D'abord, je ne vois pas où est le problème avec des pointeurs.
L'égalité (les opérateurs == et !=) sont bien défini sur le s
pointeurs, et selon le cas, c'est précisement cette définition
qu'on veut quand on a une collection de pointeurs.

D'autre part, on pourrait bien vouloir y mettre des types pour
lesquels l'égalité n'est pas définie du tout, ou vouloir un
autre critère d'égalité (des flottants à 1E-6 près, par
exemples). Ce qui suggère plutôt un surcharge de la fonction,
avec un paramètre en plus pour définir la fonction de
comparaison.

Et en passant, pourquoi pas std::list et std::find/std::find_if ?
Et à quoi sert une fonction de find qui renvoie void ?

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34



Comme je l'ai dis, je voudrais tout faire de A à Z, d'où : pas de
std::list et autre...

Pour le moment j'impose la surcharge de l'opérateur != pour
l'utilisatio de la liste, je verrais dans les versions futures si je
change ca. (Je trouve ca plus commode que de passer une fonction en
paramètre et c'est pas non plus un trop gros travail de surcharger...)

La fonction ne renvoie pas void, j'ai mis ce prototype pour faire
simple mais j'utilise un enum d'erreur... (Et ceci dit, on pourrai
imaginer que ca leve un flag trouvé/non trouvé, mais pas tres pratique
j'accorde :))

Pour répondre aux suggestions (dont je vous remercie !), je n'ai pas
du bien me faire comprendre, en fait j'utilise la liste comme ceci :
TempList<Node *>, donc meme en surchargeant find avec T *t, cela ne
fonctionne malheureusement pas... (vu que je n'appel pas avec Node **
mais bien avec Node * soit T...)

Pour la spécialisation partielle, comme je l'ai dit, je ne peux pas
spécialiser le template pour toutes les classes que je ne connais
pas... :(

Merci pour ces réponses rapides en tout cas ! Si vous avez d'autres
idées/infos, je suis preneur !!

Raphaël.
Publicité
Poster une réponse
Anonyme