Voilà un défi : problème utilisant méthode récursive

Salut à tout le monde !

J'espère qu'à vous pourrez me donner un coup de main avec un problème lié à recursivité et aux méthodes virtuelles.

J'ai une fonction virtuelle qui s'appelle inList et qui est déclaré dans la classe de base qui s'appelle Product.

La méthode inList est redéfinie dans 2 classes dérivées de Product : CompositeProduct et BasicProduct.
CompositeProduct a une attribute "std::vector<Product *> _listProduct". Ainsi on peut former des arbres composés par des BasicProducts et CompositeProducts à condition qu'à la base de l'arbre se trouve une CompositeProduct.
La finalité de la méthode inList est de repèrer si un produit se trouve dans l'arbre ou pas.

les declarations pour inList sont les suivantes :

Code:

---

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

inList declaration on class Product (classe de base): virtual bool inList(const Product * &)=0;   inList implementqtion on class CompositeProduct (qui hérite de Product): bool CompositeProduct::inList(const Product* &iProduct) { std::list<Product*>::iterator iter; if (iProduct==this) {return true;} else { for (iter=_productList.begin(); iter!=_productList.end(); iter++) inList(*iter); } }   inList implementation on class BasicProduct (aussi elle hérite de Product): bool BasicProduct::inList(const Product* & iProduct) { if (iProduct==this) return true; else return false; }

---

Quand j'essaie de compiler, le compilateur me montre les erreurs suivantes :
error: no matching function for call to ‘CompositeProduct::inList(Product*&)’
note: candidates are: virtual bool CompositeProduct::inList(const Product*&)
error: no matching function for call to ‘CompositeProduct::inList(BasicProduct*&)’
note: candidates are: virtual bool CompositeProduct::inList(const Product*&)

Quelqu'un peut m'aider svp? :)
Quelqu'un a une idée de ce qu'il faut que je fasse ?

Merci d'avance !

Citation:

---

Envoyé par donkeyquote

Code:

---

1 2 3 4 5 6 7 8 9

bool CompositeProduct::inList(const Product* &iProduct) { std::list<Product*>::iterator iter; if (iProduct==this) {return true;} else { for (iter=_productList.begin(); iter!=_productList.end(); iter++) inList(*iter); } }

---

---

bonjour ce ne devrait pas plustôt etre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

bool CompositeProduct::inList(const Product* &iProduct) { std::list<Product*>::iterator iter; if (iProduct==this) { return true; } else { for (iter=_productList.begin(); iter!=_productList.end(); iter++) (*iter)->inList(iProduct); } }

---

[EDIT]
sinon tu as peut être un problème de définition entre le .h et le .cpp

Salut, plusieurs petites choses :

:tagcode:

Pour ce qui est de l'erreur que tu obtiens :
error: no matching function for call to ‘CompositeProduct::inList(Product*&)’
note: candidates are: virtual bool CompositeProduct::inList(const Product*&)

Dans ta fonction, le if retourne un résultat, tandis que ta boucle for (dans le else) n'en retourne aucun, ce qui est non conforme à la signature de ta méthode.

La recherche dans ta liste doit effectivement se faire comme l'a indiqué Mongaulois à une petite différence près, il faut retourner un bool:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

bool CompositeProduct::inList(const Product* &iProduct) { std::list<Product*>::iterator iter; if (iProduct==this) { return true; } else { bool found = false; for (iter=_productList.begin(); iter!=_productList.end() && !found; iter++) found |= (*iter)->inList(iProduct); } return found; }

---

Salut,

Le problème vient de la const-correctness de ta fonction.

Tu déclares le paramètre en tant que const Product*&, il faut donc que tu passe un const Product&*...

Au passage, un pointeur étant un "primitif", il n'y a a piori que peu d'intérêts à le passer comme référence ;):roll:

Pour que les différents itérateurs pointent sur une référence sur pointeur constant, il faut utiliser, non pas un list<Product*>::iterator, mais bien un
list<Product>::const_iterator (et il faut, comme l'a dit bolhrak, penser à renvoyer le résultat).

Ainsi, le code (fournis par bolhark, car c'est celui qui est le plus proche de la solution) deviendrait

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

bool CompositeProduct::inList(const Product* &iProduct) { std::list<Product*>::const_iterator iter; if (iProduct==this) { return true; } else { bool found = false; for (iter=_productList.begin(); iter!=_productList.end() && !found; iter++) found |= (*iter)->inList(iProduct); } return found; }

---

Mais, si on prend ma remarque en compte pour ce qui est des pointeurs, on peut aussi simplifier le prototype de la fonction en

Code:

---

bool CompositeProduct::inList(const Product* iProduct)=0

---

et la définition de la fonction en

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

bool CompositeProduct::inList(const Product* &iProduct) { bool found = false; if (iProduct==this) { bool=true; } else { std::list<Product*>::const_iterator iter; for (iter=_productList.begin(); iter!=_productList.end() && !found; iter++) found |= (*iter)->inList(iProduct); } return found; }

---

en le "rationnalisant" quelque peu :roll:

Sa fonction demande une référence constante sur pointeur, donc a priori il n'y a aucun problème à passer une référence non constante, il y aura conversion automatique de non constant vers constant (du moins restrictif vers le plus restrictif), donc ça ne devrait pas poser de problème non ?

Pour moi le problème vient vraiment du type de retour.

Avant tout, merci les gars de vos reponses !! Vous êtes super!
Dans d'autres forums anglophones personne ne m'a aidé...

Le code que koala01 m'a donné marche bien à condition d'utiliser le pointeur comme un type primitif, c'est-à-dire sans le "const &". Je suis un peu borné et curieux et je voudrais également savoir comment faire avec "const &" dans la signature des méthodes.

Même si j'utilise un const_iterator le compilateur me montre les erreurs suivantes :
error: no matching function for call to ‘CompositeProduct::inList(BasicProduct*&)’
note: candidates are: virtual bool CompositeProduct::inList(const Product*&)

vous avez une idée de pourquoi ça arrive ? pour quoi le compilo n'arrive pas à utiliser le polimorphisme ?

Deuxième question : c'est la première fois que je vois "|=". Dans quels cas on l'outilise ?

merci bcp !!

Citation:

---

Envoyé par koala01

Salut,

Le problème vient de la const-correctness de ta fonction.

Tu déclares le paramètre en tant que const Product*&, il faut donc que tu passe un const Product&*...

---

ce ne serait pas plustot const Product*? Je ne savait qu'une référence ne convertisé pas un objet en const.

Citation:

---

Envoyé par koala01

Pour que les différents itérateurs pointent sur une référence sur pointeur constant, il faut utiliser, non pas un list<Product*>::iterator, mais bien un
list<Product>::const_iterator (et il faut, comme l'a dit bolhrak, penser à renvoyer le résultat).

Ainsi, le code (fournis par bolhark, car c'est celui qui est le plus proche de la solution) deviendrait

Mais, si on prend ma remarque en compte pour ce qui est des pointeurs, on peut aussi simplifier le prototype de la fonction en

Code:

---

bool CompositeProduct::inList(const Product* iProduct)=0

---

et la définition de la fonction en

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

bool CompositeProduct::inList(const Product* &iProduct) { bool found = false; if (iProduct==this) { bool=true; } else { std::list<Product*>::const_iterator iter; for (iter=_productList.begin(); iter!=_productList.end() && !found; iter++) found |= (*iter)->inList(iProduct); } return found; }

---

---

t'as fonction ne devrait pas plustôt être

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

bool CompositeProduct::inList(const Product* iProduct) { bool found = false; if (iProduct==this) { found =true; } else { std::list<Product*>::iterator iter; for (iter=_productList.begin(); iter!=_productList.end() && !found; iter++) found = (*iter)->inList(iProduct); } return found; }

---

avec :
- sans const_iterator car la fonction inList() n'est pas const
- sans le "|=" car il n'y en as pas besoin ici puisque found sert a sortir de la boucle



pour repondre à |=
found |= a; <=> found = found | a;

Pas de soucis, ce forum est fait pour ça ;)

Pour l'opérateur |=, en gros :

Code:

---

1 2	b |= un_bool

---

est équivalent à :

Code:

---

1 2	b = b || un_bool

---

En gros ça te permet de garder "l'effet" des résultats des itérations précédentes sur le résultat global. C'est vrai que dans le cas présent, étant donné que ton bool est dans la condition d'arrêt ça sert pas à grand chose.

Code:

---

1 2	found = (*iter)->inList(iProduct)

---

marcherait tout aussi bien.

Pour ce qui est de l'utilisation des pointeurs et des références, comme l'a dit koala, un pointeur étant primitif, il y a peu d'intérêt à le passer par référence (les seuls cas d'utilisation que j'ai vu de cette méthode sont lorsque la méthode appelée doit allouer le pointeur passé en paramètre et/ou changer l'adresse du pointeur, dans ce cas là on ne peut pas passer le pointeur par copie, mais bon ça reste relativement marginal). Donc tu peux utiliser les références à la place des pointeurs :

Code:

---

bool CompositeProduct::inList(const Product& iProduct)

---

Le polymorphisme marchera aussi bien qu'avec les pointeurs.

EDIT : grilled par Mongaulois :aie:

attention

Code:

---

1 2	b |= un_bool;

---

n'est pas équivalent à :

Code:

---

1 2	b = b || un_bool;//operation boolen

---

mai à

Code:

---

1 2	b = b | un_bool;//operation booleen bit à bit

---