Je suis sur un ptit projet perso que j'aimerais faire de A =E0 Z (sans
utiliser de lib existante, ca peut paraitre bete, mais ca me
motive :)) et je coince sur des templates m=E9l=E9s =E0 des pointeurs...
Pour faire simple : j'ai fait une liste chain=E9e g=E9n=E9rique
(TempList<T>) dans laquelle j'ai une m=E9thode "void find(T &t)" qui se
positionne sur l'=E9l=E9ment "t".
Probl=E8me : cette m=E9thode utilise bien sur l'op=E9rateur !=3D. Aucun
probl=E8me 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=E9cification (=E9tant donner que ca doit =EAtre r=E9utilisable, je ne pe=
ux
sp=E9cifier chaque type, vu que je ne les connais pas) ?
Pour plus de d=E9tail, au cas ou cela ne suffise pas, j'ai une classe
complexe (Node) qui contient en donn=E9e priv=E9e un identifiant (unsigned
long) et j'ai surcharg=E9 l'op=E9rateur !=3D, le probl=E8me est que je stoc=
k
dans la liste des pointeurs (Node *). Evidement, il compare les
adresse et ne cherche meme pas a acceder =E0 l'op=E9rateur surcharg=E9... J=
e
ne veux pas stocker de "Node", pour des raisons de duplication en
m=E9moire (j'ai plusieurs listes de node et donc des noeuds en double,
triple, voir plus...)
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
David Côme
On Thu, 10 Jul 2008 17:13:39 +0200, Raph` wrote:
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* ?
On Thu, 10 Jul 2008 17:13:39 +0200, Raph` <apocalipsia@gmail.com> wrote:
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...)
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
"Raph`" writes:
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:
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:
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:
On Jul 10, 5:35 pm, (Pascal J. Bourguignon) wrote:
"Raph`" writes:
> 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:
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
On Jul 10, 5:35 pm, p...@informatimago.com (Pascal J. Bourguignon)
wrote:
"Raph`" <apocalip...@gmail.com> writes:
> 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:
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:james.kanze@gmail.com
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
On Jul 10, 5:35 pm, (Pascal J. Bourguignon) wrote:
"Raph`" writes:
> 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:
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`
On 11 juil, 09:35, James Kanze wrote:
On Jul 10, 5:35 pm, (Pascal J. Bourguignon) wrote:
> "Raph`" writes: > > 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:
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.
On 11 juil, 09:35, James Kanze <james.ka...@gmail.com> wrote:
On Jul 10, 5:35 pm, p...@informatimago.com (Pascal J. Bourguignon)
wrote:
> "Raph`" <apocalip...@gmail.com> writes:
> > 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:
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:james.ka...@gmail.com
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 !!
On Jul 10, 5:35 pm, (Pascal J. Bourguignon) wrote:
> "Raph`" writes: > > 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:
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 !!
