Discussion :

[donkeyquote]

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 :

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
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 !

[yan]

Code C++ :

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

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 C++ :

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

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

[bolhrak]

Salut, plusieurs petites choses :



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 :

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

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;
}

[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&*...

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

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 :

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

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 :

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

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

et la définition de la fonction en

Code :

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

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

[bolhrak]

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.

[donkeyquote]

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 !!

[yan]

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.

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 :

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

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

et la définition de la fonction en

Code :

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

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 :

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

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;

[bolhrak]

Pas de soucis, ce forum est fait pour ça

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

Code :

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

1
2
 
b |= un_bool

est équivalent à :

Code :

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

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 :

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

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 :

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

bool CompositeProduct::inList(const Product& iProduct)

Le polymorphisme marchera aussi bien qu'avec les pointeurs.

EDIT : grilled par Mongaulois

[yan]

attention

Code :

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

1
2
 
b |= un_bool;

n'est pas équivalent à :

Code :

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

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

mai à

Code :

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

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