Discussion :

[le y@m's]

bonjour a tous,

j'ai un petit probleme avec la surcharge d'operateur.
j'ai une classe Maclasse qui possede entre autre un membre entier.
je souhaite que la comparaison de deux instances de Maclasse revienne à faire la comparaison de leur membre entier respectif ( c'est pas clair)

Maclasse.h

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
 
#ifndef MACLASSE_H
#define MACLASSE_H
 
class Maclasse 
{
      public:
             Maclasse (int = 0);
             int getint() const;
             bool operator < (Maclasse);
             bool operator > (Maclasse);
             bool operator == (Maclasse);
             bool operator != (Maclasse);
...
      private:
              int entier;
...
 
};
#endif

Maclasse.cpp

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
#include <iostream>
#include "Maclasse.h"
 
using namespace std;
 
Maclasse:: Maclasse(int i)
{
         entier = i;
}
 
int Maclasse:: getint() const
{
    return entier;     
}
 
bool Maclasse:: operator < (Maclasse m)
{
          cout << "operator <" << endl;
          return(entier < m.getint());
}
 
bool Maclasse :: operator > (Maclasse m)
{
         cout << "operator >" << endl;
         return(entier > m.getint());
}
 
bool Maclasse :: operator == (Maclasse m)
{
         cout << "operator ==" << endl;
         return(entier == m.getint());
}
 
bool Maclasse :: operator != (Maclasse m)
{
         cout << "operator !=" << endl;
         return(entier != m.getint());
}

main.cpp

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
26
27
28
29
 
#include <iostream>
#include "Maclasse.h"
 
using namespace std;
 
int main ()
{
    maclasse a(1);
    maclasse b(2);
 
    if(a < b)
    {
         cout << "a(1) < b(2)" << endl;
    }
    if(a > b)
    {
        cout << "a(1) > b(2)" << endl;
    }
    if(a == b)
    {
        cout << "a(1) == b(2)" << endl;
    }    
    if(a != b)
    {
        cout << "a(1) != b(2)" << endl;
    }
    return 0;
}

l'execution donne :

operator: <
a(1) < b(2)
operator: >
operator: ==
operator: !=
a(1) != b(2)

bon, a priori jusque là ça fonctionne.
j'en viens (enfin) à mon probleme:
je voudrais utiliser des pointeurs de Maclasse :

Code :

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

1
2
3
4
 
maclasse *a = new maclasse(1);  // au lieu de: maclasse a(1);
maclasse *b = new maclasse(2);  // au lieu de: maclasse b(2);
...

bien entendue les operateurs ne marchent pas.
si quelqu'un peut m'aiguiller sur comment utiliser ET la surcharge des opérateurs ET les pointeurs...
merci d'avance.

[Laurent Gomila]

Si tu compares a et b tu vas comparer des pointeurs. Si tu veux comparer les valeurs pointées il suffit de comparer *a et *b.

Remarque qui ne mange pas de pain : tu devrais passer tes paramètres par référence constante. Tu devrais également implémenter un maximum d'opérateurs en fonction d'autres (au moins != en fonction de ==). Pour des classes très petites ça ne change rien, mais dès que celle-ci va grossir tu vas augmenter le risque d'incohérences / erreurs.

[le y@m's]

Si tu veux comparer les valeurs pointées il suffit de comparer *a et *b

donc dans le main je doit coder :

Code :

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

if(*a < *b)

impec! 8)

Tu devrais également implémenter un maximum d'opérateurs en fonction d'autres (au moins != en fonction de ==)

c'est-a-dire ?

[Laurent Gomila]

C'est à dire :

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
26
27
28
29
bool MaClasse::operator <(const MaClasse& m) const
{
    return entier < m.entier;
}
 
bool MaClasse::operator ==(const MaClasse& m) const
{
    return !(*this < m) && !(m < *this);
}
 
bool MaClasse::operator !=(const MaClasse& m) const
{
    return !(*this == m);
}
 
bool MaClasse::operator >(const MaClasse& m) const
{
    return !(*this < m) && !(*this == m);
}
 
bool MaClasse::operator >=(const MaClasse& m) const
{
    return !(*this < m);
}
 
bool MaClasse::operator <=(const MaClasse& m) const
{
    return !(*this > m);
}

Si tu modifies ta classe, tu n'auras que < à modifier.

Attention dans certains cas, égalité (== et !=) et équivalence (<, >, <= et >=) ne seront pas en relation, il faudra donc les séparer.

[le y@m's]

super cool la technique...mais
comme j'ai passer les paramètres par référence constante, devcpp geule :

30 C:\Dev-Cpp\tests\3\maclasse.cpp passing `const maclasse' as `this' argument of `bool maclasse::operator<(const maclasse&)' discards qualifiers

je suppose que *this n'est pas consideré comme const et donc la ligne

Code :

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

return !(*this < m) && !(m < *this);

pose un probleme

[Laurent Gomila]

je suppose que *this n'est pas consideré comme const

Non, ce sont tes fonctions qui ne sont pas const. Si tu regardes attentivement tu verras qu'elles le sont dans mon code.

[le y@m's]

Non, ce sont tes fonctions qui ne sont pas const. Si tu regardes attentivement tu verras qu'elles le sont dans mon code.

oups desole

En tout cas maintenant ça marche nickel
beaucoup