Discussion :

[APoLLoN1234]

Bonjour lorsque j'utilise la fonction std::find, j'obtiens le code d'erreur suivant:


Voici les éléments qui vont dans le std::find

Code :

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

1
2
std::list<CCasePathFinding *> *m_OpenList;
   std::vector<CCasePathFinding *> *m_CloseList;

j'utilise std::find de cette maniere:

Code :

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

std::find(m_OpenList->begin(),m_OpenList->end(),*oUneCase);

j'obtiens le code d'erreur suivant:

Code :

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

Erreur	14	error C2679: '==' binaire : aucun opérateur trouvé qui accepte un opérande de partie droite de type 'const CCasePathFinding' (ou il n'existe pas de conversion acceptable)	c:\program files\microsoft visual studio 8\vc\include\algorithm	40

pourtant, la classe CCasePathFinding j'ai ajouté les surcharges d'opérateurs suivantes:

Code :

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

1
2
bool operator == (const CCasePathFinding *oCase) const;
   bool operator == (const CCasePathFinding oCase) const;

je ne comprend pas pourquoi il me dit qu'il ne trouve pas de surcharge d'opérateur approprié

merci de l'aide que vous pourrez m'apporter

[Invité]

Personnellement j'essayerais d'ajouter cet opérateur dans la classe "CCasePathFinding" :

Code :

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

1
2
3
4
5
6
 
   // Opérateur de comparaison std::equal pour std::find
   friend bool operator==( const CCasePathFinding * oCase1, 
                           const CCasePathFinding * oCase2 ) {
      return ( oCase1-> ... == oCase2-> ... ) ;// à compléter
   }// operator ==

[Laurent Gomila]

Ce qu'il te faudrait c'est un opérateur de comparaison entre un CCasePathFinding* et un CCasePathFinding (et pas dans l'autre sens). Tu peux le faire si tu définis un opérateur non-membre, mais bon c'est tout sauf élégant.

Quant à la solution de Kaji, ça ne marchera pas car d'une part ce n'est pas l'opérateur dont tu as besoin, et même si c'était le cas tu n'as pas le droit de définir un opérateur entre deux types de base (un pointeur en est un).

La solution est beaucoup plus simple : utilise std::find_if.

[Invité]

Quant à la solution de Kaji, ça ne marchera pas

Pour un tri de std::list<A> liste, avec "liste.sort()", l'opérateur à ajouter dans la classe A est :

Code :

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

1
2
3
4
 
friend bool operator < ( const A & a1, const A & a2) {
  return (a1.strNom_ < a2.strNom_ );
}// operator <

(strNom_ est une variable membre de A, je viens de le compiler avec DevCpp)

Ce n'est peut-être pas la meilleure solution mais elle fonctionne...

ce n'est pas l'opérateur dont tu as besoin

Que proposes-tu comme opérateur ?

[Invité]

Effectivement, ma fonction de comparaison ne marcherait que dans le cas std::list<CCasePathFinding>.

Mais, APoLLoN1234, comme tu as une liste de pointeurs (std::list<CCasePathFinding*>), il faut utiliser, (comme le préconisait Laurent) ce genre de code (j'ai récupéré l'exemple sur // www.gamedev.net) :

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
23
24
 
class Poop {
    int mID;
public:
    int getID() { return mID;};    
};// Poop
 
 
class Finder {
	int mID;
public:    
	Finder(int id): mID( id ) {}
 
	bool operator()( Poop *test ) {
		return test->getID() == mID;
	}
};// Finder
 
...
 
std::vector<Poop*> myPoops;
 
// ( on recherche le "Poop" d'ID 4 )
std::find_if( myPoops.begin(), myPoops.end(), Finder(4) );

Mais ce n'est pas vraiment plus simple que std::find car il faut ajouter une classe Finder...

[yan]

Mais ce n'est pas vraiment plus simple que std::find car il faut ajouter une classe Finder...

C'est le principe du foncteur(ici c'est un predicat). C'est même beaucoup pus propre, simple a comprendre, trés reutilisable et puissant une fois bien compris. Cela peut même etre très performante. Associé au inline,
c'est la raison que le std::sort soit une référence . En générale on utilise plustôt une struct :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
std::vector<Poop*> myPoops;
...//init du vector
 
struct Finder {
	Finder(int id): mID( id ) {}
	inline bool operator()(const  Poop * & test ) {
		return test->getID() == mID;
         const int mID;
	}
};
std::find_if( myPoops.begin(), myPoops.end(), Finder(4) );

Définie comme cela, il me semble que le inline ne sert a rien, car la fonction sera déja inliné.

[Invité]

C'est le principe du foncteur(ici c'est un predicat). C'est même beaucoup pus propre, simple a comprendre, trés reutilisable et puissant une fois bien compris.

Oui, ça a aussi l'avantage de créer des fonctions de recherche séparées qui n'impactent pas le code des objets recherchés (poop).

En général on utilise plustôt une struct

La seule différence entre une "struct" et une "class", c'est de rendre tous les membres publics par défaut... Je ne sais pas si c'est toujours une bonne idée...

[yan]

La seule différence entre une "struct" et une "class", c'est de rendre tous les membres publics par défaut... Je ne sais pas si c'est toujours une bonne idée...

moins verbeux ?
je croit que ca peut jouer sur le inline. mais j'en sais rien en faite

[NiamorH]

Définie comme cela, il me semble que le inline ne sert a rien, car la fonction sera déja inliné.

Oui, toute définition de fonction membre écrite dans la définition même d'une class/struct est implicitement inline (sous réserve que le compilo arrive à l'inliner).

Code :

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

1
2
3
4
5
class C
{
  // implicitement inline
  void func {}
};

[yan]

tu veut dire comme cela?

Code :

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

1
2
3
4
5
class C
{
  // implicitement inline
  void func () {}
};

[/QUOTE]

[NiamorH]

plutôt en effet