operator== : problème comparaison d'objets pointés

Version imprimable

Bonjour,

Voici un petit bout de code, les explications suivront celui-ci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Activity { int order; std::string action; public: ... bool operator==(const Activity &activity) const { return activity.isOrder(order) && activity.isAction(action); }; }
En fait, la classe Activity, comme d'autres classes, seront utilisés dans un graphe générique. Il y aura une recherche, finissant par une comparaison, ce qui m'amène pour un type template Vertex à faire comme tel :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 template<class Vertex> class Graph { ... }; ... template<class Vertex> bool Graph<Vertex>::isValid(Vertex v) { // recherche return (v == v2); } ... Graph<int> integerGraph; Graph<Activity *> activityGraph;
Si Vertex = int, je me vois de laisser une comparaison sans pointeur (v == v2).
Mais si Vertex = Activity*, cette comparaison ne marche pas, car il faudrait alors (*v == *v2) qui, elle, fonctionne.
J'ai cru pouvoir résoudre le problème en redéfinissant l'opérateur == dans la classe Activity d'une autre manière (déréférencé le pointeur grâce à l'argument) :
Code:

1 2 3 4 5 bool operator==(const Activity *activity) const { return activity->isOrder(order) && activity->isAction(action); };
Mais la comparaion (v == v2) échoue.
C'est indispensable pour moi de trouver une déclaration de l'opérateur == dans la classe Activity qui me permet de garder le format de comparaison (v == v2) lors de la recherche dans la classe Graph.
J'espères que vous aurez une solution pour moi. Merci d'avance pour votre aide !

03/05/2006, 08h58
Swoög
Salut !

Je pense qu'il faudrait que tu spécialises la fonction [/code]template<class Vertex> bool Graph<Vertex>::isValid(Vertex v)[/code]
pour prendre en compte le fait que Vertex puisse représenter un pointeur, c'est à dire :
Code:

1 2 3 4 5 6 template<class Vertex> bool Graph<Vertex*>::isValid(Vertex* v) { // recherche return (*v == *v2); }
comme ça, ainsi, si ton Graph contient des pointeurs, alors ce sont les objets pointés qui seront comparés...

cependant, fait attention, parce que si on veut VRAIMENT que ton Graphe contienne des pointeurs, (c'est à dire, dans ce cas, que ce soient les pointeurs et non les valeurs qui devraient être égales) cela posera sûrement problème ;)

Il y a peut-être une erreur de modélisation quelque part ^^
03/05/2006, 09h02
skrenit0

J'ai du mal à comprendre ta solution..
Si je fais Graph<Activity *> myGraph, alors, dans ton cas, Vertex sera égal à Activity**. Si je ne me trompes pas, ce n'est pas vraiment ce que je souhaites. Peut-être ais-je manqué une subtilité.
Sinon, si on suppose qu'on ne veut pas que mon graphe contienne vraiment des pointeurs, est-ce qu'il existe une solution plus.. radicale ?
03/05/2006, 09h09
Swoög

alors, non

il s'agit de spécialisation, c'est à dire que quand tu appelleras

Code:

bool Grap<Activity*>::isValid(Activity*);

il recherchera les fonctions template correspondante, la première sera :

Code:

template<class Vertex> bool Graph<Vertex>::isValid(Vertex);

au quel cas, Vertex se voit être égale à Activity*
la seconde est :

Code:

template<class Vertex> bool Graph<Vertex*>::isValid(Vertex*);

Auquel cas, Vertex se vois être égal à Activity, le * étant sépcifé explicitement ;)

Le second cas est "plus précis", plus spécialisé...
de même, si par exemple tu faisais une spécialisation pour les vecteurs :

Code:

template<class Vertex> bool Graph< vector<Vertex> >::isValid(vector<Vertex>);

ou pour d'autres types ;)
c'est la signature la plus spécialisée qui l'emporte...

je pense que tu as compris ?
(exemple, une spécialisation pour les pointeurs const :

Code:

template<class Vertex> bool Graph<const Vertex*>::isValid(const Vertex*);

comme il y en a deux pour les pointeurs, si tu utilises un Graph<Activity*> c'est celle en Vertex* qui sera utilisée (on ne peut pas utiliser const Vertex*) et si tu utilises un Graph<const Activity*> c'est celle en const Vertex* qui le sera, car plus spécialisée (dans le premier cas (général) Vertex représente const Activity*, dans le second (pointeurs) il représente const Activity, et dans le dernier, uniquement Activity)
J'espère que c'est un peu plus clair ? ;)
03/05/2006, 09h28
skrenit0
Effectivement, mais je voudrais éviter la spécialisation, car je ne traite que des Activity* tout au long de mon algorithme, pour un des graphes. Mais pour d'autres, j'utilises des strings ou des ints.. :?
Je voudrais vraiment arriver à un résultat du type :
Code:

1 2 3 4 5 6 7 8 Activity *one = new Activity(1); Activity *two = new Activity(1); if (one == two) cout << "ok" << endl; else cout << "nok << endl;
Je voudrais donc overloadé l'opérateur == avec un paramètre autre que const Activity &activity (car dans ce cas, il faut faire une comparaison *one == *two pour que ça fonctionne) tel que je puisses faire une comparaison one == two.
Je souhaites vraiment avoir un même algorithme capable de s'adapter à des objets de tout type. N'y a-t-il vraiment pas une solution autre que la spécialisation ?

Comme il est difficile de passer par la spécialisation, ainsi que le démontre fort justement Swoög ci-dessus, je pense qu'il faudrait essayer de passer par un adaptateur. L'idée serait de créer une classe légère te permettant de traiter un pointeur comme un type non pointé dans les cas qui t'intéressent.

Quelque chose comme ça, donc :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 template< class T > class Unptr { public : Unptr( T* ptr ) : m_ptr( ptr ) {} const T* get() const { return m_ptr; } bool operator ==( const Unptr< T >& rhs ) { return *m_ptr == * rhs.get(); } [etc...] private : T* m_ptr; };
Moyennant quoi :
Code:

1 2 3 4 5 6 7 8 9 10 int* p1 = new int( 5 ); int* p2 = new int( 5 ); Unptr< int > up1( p1 ); Unptr< int > up2( p2 ); bool eq = up1 == up2; cout << eq << endl; [delete...]
se comporte comme il faut.
Si contruire des Graph< Unptr< Activity > > au lieu des Graph< Activity* > est envisageable, ce type d'approche peut peut-être aider.

03/05/2006, 10h20
Matthieu Brucher

Pourquoi ne pas surcharger l'operateur == avec les 2 pointeurs en argument ?
De toute manière, il ne vaudrait mieux pas que operator== soit défini dans la classe à moins qu'il ait absolument besoin d'un élément auquel on ne pourrait pas avoir accès. Il peut même être défini en fonction d'une fonction membre de la classe.

J'ai bien tenté en faisant :

Code:

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 Activity
{
    int order;
    std::string action;
 
public:
 
    Activity(int order) : order(order), action("") {};
 
    int getOrder() const { return order; };
    void setOrder(int _order) { order = _order; };
    bool isOrder(int _order) const { return order == _order; };
 
    std::string getAction() const { return action; };
    void setAction(std::string _action) { action = _action; };
    bool isAction(std::string _action) const { return action == _action; };
};
 
bool operator==(Activity *activity1, Activity *activity2)
{
    return activity1->isOrder(activity2->getOrder()) &&
    activity1->isAction(activity2->getAction());
}

Mais j'obtiens l'erreur suivante. Pourrais-tu m'éclairer ?!

Code:

1
2
3
 
error: `bool operator==(const Activity*, const Activity*)' must
     have an argument of class or enumerated type

03/05/2006, 10h45
Matthieu Brucher

Bon, apparemment, on a pas le droit de faire ça :|
03/05/2006, 15h35
Swoög
Miles !!

Quand on surcharge un opérateur (binaire), une opérande au moins DOIT être de type utilisateur...
dans le cas Activity* == Activity*, il s'agit de deux types de base (pointeurs)

Je pense que l'adaptateur est une bonne idée, sinon, que penses-tu d'une modification de ton template :
Code:

1 2 template<class Vertex, bool Equal(const Vertex&, const Vertex&)> class Graph ...
qui te permettrait de définir une fonction ou un foncteur de te permettant de replacer l'opérateur d'égalité...
Auquel cas, tu pourrais même faire, une fonction pour avoir une valeur par défaut, exemple :
Code:

1 2 template<class Vertex> inline bool default_graph_equal(const Vertex& a, const Vertex& b) { return a == b; }
dans ce cas, ta fonction devient :
Code:

1 2 3 4 5 template<class Vertex, bool Equal(const Vertex&, const Vertex&)> bool Graph<Vertex, Equal>::isValid(Vertex v) { //recherche return Equal(v, v2); }

Effectivement Swoög, c'était une des approches envisagées. J'ai finalement opté pour une option m'évitant de devoir modifier mes templates. Merci à tous pour votre aide. Voici ce que j'ai fais :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
#ifndef __EQUAL_H
#define __EQUAL_H
 
#include "Structures.h"
 
template <class T>
struct Equal
{
    bool operator()(T first, T second) const { return first == second; };
};
 
template <>
struct Equal<pActivity>
{
    bool operator()(pActivity first, pActivity second) const { return *first == *second; };
};
 
template <>
struct Equal<pLink>
{
    bool operator()(pLink first, pLink second) const { return *first == *second; };
};
 
#endif

Merci encore :D

03/05/2006, 16h43
Matthieu Brucher

Citation:

Envoyé par Swoög

Miles !!

Quand on surcharge un opérateur (binaire), une opérande au moins DOIT être de type utilisateur...
dans le cas Activity* == Activity*, il s'agit de deux types de base (pointeurs)

C'est une des premières fois que je me plante dans ce que je dis, alors mollo...
De plus, si l'une des opérandes doit être de type utilisateur, alors il vaut peut-être aussi mieux que les 2 le soit.
03/05/2006, 17h00
Swoög

Citation:

Envoyé par Miles

C'est une des premières fois que je me plante dans ce que je dis, alors mollo...

Rôôô, c'est bon, ça m'étonnais venant de toi de te planter sur un truc comme ça, c'est tout... le prend pas mal, désolé si ç'a été le cas ;)

Citation:

Envoyé par Miles

De plus, si l'une des opérandes doit être de type utilisateur, alors il vaut peut-être aussi mieux que les 2 le soit.

ça dépend, pense à l'opérateur [] par exemple, la seconde opérande (celle entre les crochets est le plus souvent un type de base (int), de plus, pour certains opérateurs tels que les comparaisons, ou les décalages (>>, <<), ça peut être utile qu'une des deux opérandes soit un type de base...

Citation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
template <class T>
struct Equal
{
    bool operator()(T first, T second) const { return first == second; };
};
 
template <>
struct Equal<pActivity>
{
    bool operator()(pActivity first, pActivity second) const { return *first == *second; };
};
 
template <>
struct Equal<pLink>
{
    bool operator()(pLink first, pLink second) const { return *first == *second; };
};

Pourquoi pas ceci ?

Code:

1
2
3
4
5
6
7
8
9
10
11
template <class T>
struct Equal
{
    bool operator()(T first, T second) const { return first == second; };
};
 
template <typename T>
struct Equal<T*>
{
    bool operator()(T* first, T* second) const { return *first == *second; };
};

03/05/2006, 17h41
Swoög

on revient au même problème : spécialisation de template XD:mouarf:
03/05/2006, 17h43
Laurent Gomila

Il est possible que j'ai loupé un truc. C'était quoi le problème avec la spécialisation ?
03/05/2006, 17h45
Swoög

Citation:

Envoyé par Laurent Gomila

Il est possible que j'ai loupé un truc. C'était quoi le problème avec la spécialisation ?

Soit disant trop difficile à utiliser ;)
03/05/2006, 17h50
Laurent Gomila

Citation:

Envoyé par Swoög

Soit disant trop difficile à utiliser ;)

:koi:
Au contraire c'est beaucoup plus simple.

Bon après, si il utilise Visual C++ 6 pour compiler, on peut en reparler.
03/05/2006, 19h10
Matthieu Brucher

Citation:

Envoyé par Swoög

Soit disant trop difficile à utiliser ;)

:|
Bon c'est sûr que si on rajoute dans le tas des fonctions surchargées, ça peut être sur de savoir laquelle est appelée :mouarf::mouarf:

Citation:
Envoyé par Laurent Gomila
Pourquoi pas ceci ?
Code:

1 2 3 4 5 6 7 8 9 10 11 template <class T> struct Equal { bool operator()(T first, T second) const { return first == second; }; }; template <typename T> struct Equal<T*> { bool operator()(T* first, T* second) const { return *first == *second; }; };
Je ne comprends pas trop cette syntaxe, mais j'imagines que c'est ce que je souhaites.. Je vais tester tout ça :)

04/05/2006, 08h18
Laurent Gomila

En gros toi tu spécialises pour chaque type de pointeur que tu dois gérer, moi je spécialise pour tous les pointeurs une fois pour toute.
04/05/2006, 11h09
skrenit0

Cette solution est parfaite et convient tout à fait à mon problème :)
Merci à tous.