Discussion :

[skrenit0]

Bonjour,

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

Code :

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

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 :

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

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 :

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

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 !

[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 :

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

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

[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 ?

[Swoög]

alors, non

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

Code :

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

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

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

Code :

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

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

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

Code :

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

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 :

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

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 :

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

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 ?

[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 :

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

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 ?

[Herode]

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 :

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

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 :

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

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.

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

[skrenit0]

J'ai bien tenté en faisant :

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

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

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

[Matthieu Brucher]

Bon, apparemment, on a pas le droit de faire ça

[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 :

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

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 :

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

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 :

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

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

[skrenit0]

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 :

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

[Matthieu Brucher]

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.

[Swoög]

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

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

[Laurent Gomila]

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

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

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

[Swoög]

on revient au même problème : spécialisation de template XD

[Laurent Gomila]

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

[Swoög]

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

Soit disant trop difficile à utiliser

[Laurent Gomila]

Soit disant trop difficile à utiliser

Au contraire c'est beaucoup plus simple.

Bon après, si il utilise Visual C++ 6 pour compiler, on peut en reparler.

[Matthieu Brucher]

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

[skrenit0]

Pourquoi pas ceci ?

Code :

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

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