declaration opérateurs avec l'objet courant

Version imprimable

07/11/2016, 22h11
CANADG

declaration opérateurs avec l'objet courant

Bonjour ,
le suis débutant en programmation C++ et j'ai du mal à déclarer les opérateurs < et <= en utilisant :*this (l'objet courant).
Est ce que quelqu'un peut m'aider sur ça.
Merci d'avance .
08/11/2016, 09h07
Bktero

Bonjour,

Il suffit de consulter la section sur la surcharge des opérateurs de la :faq:.

En particulier cette entrée : http://cpp.developpez.com/faq/cpp/?p...l-operateur-lt

Je suggère d'écrire une fonction friend compare qui centralise la logique de comparaison de la classe/structure.
La surcharge des opérateurs souhaités est ensuite aisée.
Voici un exemple assez général:
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 26 27 28 29 30 31 32 33 34 class MyClass { std::string one; int two; //bazar_truc three; public: friend intptr_t compare(MyClass const & l, MyClass const & r) { intptr_t cmp = l.one.compare(r.one); if (cmp == 0) { cmp = (l.two - r.two); //if (cmp == 0) // cmp = compare(l.three, r.three); // etc... } return cmp; } }; inline bool operator<(MyClass const & l, MyClass const & r) { return compare(l, r) < 0; } inline bool operator==(MyClass const & l, MyClass const & r) { return compare(l, r) == 0; } inline bool operator>=(MyClass const & l, MyClass const & r) { return compare(l, r) >= 0; }
Maintenant, si pour une raison ou une autre on tient absolument à utiliser en cascade les opérateurs déjà surchargés des sous-objets, une solution ressemblerait à ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class MyClass { std::string one; int two; //bazar_truc three; public: bool operator<(MyClass const & v) const { return (this->one < v.one || (!(v.one < this->one) && (this->two < v.two /*|| (!(v.two < this->two) && this->three < v.three)*/))); } };
Mais je trouve cette autre approche fastidieuse et sujette à erreur s'il faut écrire plusieurs operateurs.

Il existe une astuce, dont j'ai plus le nom si tenté qu'il y en ait un, pour n'avoir à écrire que 2 opérateurs et que tous les autres se déduisent à partir de ces deux-là : == et <
Code:

1 2 3 4 5 6 bool operator==(const T& l, const T& r) { return ...; } bool operator<((const T& l, const T& r) { return ...; } bool operator!=(const T& l, const T& r) { return !(l == r); } bool operator<=(const T& l, const T& r) { return (l == r) || (l < r); } bool operator>(const T& l, const T& r) { return !(l == r) && !(l < r); } bool operator>=(const T& l, const T& r) { return (l == r) || !(l < r); }
En théorie il est même possible de n'utiliser que operator< avec bool operator==(const T& l, const T& r) { return !(l < r) && !(r < l); } mais avoir l'implémentation de == peut accélérer les choses selon la complexité de l'opérateur <.

C'est même plus simple que ça encore ;)
Voici:

Code:

1
2
3
4
5
6
bool operator==(const T& l, const T& r) { return ...; }
bool operator<(const T& l, const T& r) { return ...; }
bool operator!=(const T& l, const T& r) { return !(l == r); }
bool operator<=(const T& l, const T& r) { return !(r < l); }
bool operator>(const T& l, const T& r) { return (r < l); }
bool operator>=(const T& l, const T& r) { return !(l < r); }

Citation:
Envoyé par camboui
Je suggère d'écrire une fonction friend compare qui centralise la logique de comparaison de la classe/structure.

Maintenant, si pour une raison ou une autre on tient absolument à utiliser en cascade les opérateurs déjà surchargés des sous-objets, une solution ressemblerait à ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class MyClass { std::string one; int two; //bazar_truc three; public: bool operator<(MyClass const & v) const { return (this->one < v.one || (!(v.one < this->one) && (this->two < v.two /*|| (!(v.two < this->two) && this->three < v.three)*/))); } };
Mais je trouve cette autre approche fastidieuse et sujette à erreur s'il faut écrire plusieurs operateurs.
Merci pour vos réponses.
Je vais utiliser la solution ci-dessus car je dois utiliser *this (l'objet courant). Mais dans mon cas j'ai une classe temps donc je dois comparer heures,minutes et secondes.
Sinon j'ai pas compris ce morceau de code :
Code:

1 2 3 return (this->one < v.one || (!(v.one < this->one) && (this->two < v.two /*|| (!(v.two < this->two) && this->three < v.three)*/)));
c'est quoi le one ,two , three ...est ce que je dois mettre à leurs places heure minute et seconde ?

08/11/2016, 17h31
Bousk

@Camboui> dans l'absolu oui, mais il faut prendre en compte la complexité de l'opérateur== face à l'opérateur<, découper en utilisant == autant que possible peut être bénéfique performencement parlant :P

Citation:

je dois utiliser *this

C'est vriament l'énoncé ? Et personne ne lui a fait remarquer que ça ne veut rien dire ?
Il veut quoi ? Voir juste un *this apparaître dans le code ? :weird:
08/11/2016, 17h40
CANADG

Citation:

Envoyé par Bousk

@Camboui> dans l'absolu oui, mais il faut prendre en compte la complexité de l'opérateur== face à l'opérateur<, découper en utilisant == autant que possible peut être bénéfique performencement parlant :P

tu veux dire que je doit déclarer aussi l'opérateur ==?

Citation:

Envoyé par Bousk

C'est vriament l'énoncé ? Et personne ne lui a fait remarquer que ça ne veut rien dire ?
Il veut quoi ? Voir juste un *this apparaître dans le code ? :weird:

exactement l'utilisation de l'objet local this est obligatoire :) je ne vois pas pourquoi mais c'est bien le cas.
08/11/2016, 18h32
camboui
@Bousk, le but de ma réponse était de donner plus de visibilité à ta proposition ;).

A propos de performance, je pense qu'elle a lieu à trois moments distincts, tous importants:
-le temps dévolu au développement,
-la vitesse d'exécution du code,
-le temps dévolu à la maintenance.

L'idéal étant de réunir les trois :D
L'approche que j'ai proposé en passant par une fonction compare réunit les trois me semble-t-il.

Mais notre ami @CANADG veut une solution "académique" pour son operator<, voici une des meilleures je crois:
Code:

1 2 3 4 return ((((this->heure * 64) + this->minute) * 64) + this->seconde) < ((((v.heure * 64) + v.minute) * 64) + v.seconde);
Simple, lisible et performante. Et elle utilise this :mrgreen:

Et oui, j'ai bien multiplié par 64 et non 60, c'est exprès. Et il n'y a aucun branchement conditionnel, c'est aussi exprès.

Salut,

De manière générale, il y a deux possibilités :
Soit on compare l'objet courant à "un autre", sous une forme qui serait proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 class MaClasse{ public: /* ... */ bool operator ==(MaClasse const &) const; bool operator <(MaClasse const &) const; bool operator >(MaClasse const &) const; bool operator <=(MaClasse const &) const; bool operator >=(MaClasse const &) const; private: /* ... */ };
soit on utilise des fonctions libres pour la comparaison, sous une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class MaClasse{ public: /* ... */ private: /* ... */ }; bool operator ==(MaClasse const &, MaClasse const &) const; bool operator <(MaClasse const &, MaClasse const &) const; bool operator >(MaClasse const &, MaClasse const &) const; bool operator <=(MaClasse const &, MaClasse const &) const; bool operator >=(MaClasse const &, MaClasse const &) const;
Dans le premier cas, comme il s'agit de fonctions membres, les opérateurs ont forcément accès à l'ensemble des membres de la classe, et this est implicite, si bien qu'une code proche de
Code:

1 2 3 4 bool MaClasse::operator == (MaClasse const & other) const{ return membre1 == other.membre1 && membre2 == other.membre2; }
est tout à fait similaire au code
Code:

1 2 3 4 bool MaClasse::operator == (MaClasse const & other) const{ return this->membre1 == other.membre1 && this->membre2 == other.membre2; }
Par contre, si on n'envisage de fournir que des fonctions libres, il n'y a pas d'objet courant (vu qu'il y a... l'objet qui correspond à l'opérande de gauche et celui qui correspond à l'opérande de droite), et il peut être intéressant de déclarer au minimum l'opérateur < et (éventuellement) l'opérateur == comme étant ami(s) de la classe.

Maintenant, il est aussi possible de combiner les deux et d'avoir les opérateurs sous forme de fonction membre ET sous forme de fonction libre.

Dans ce cas, l'implémentation des opérateurs sous forme de fonction membre feront sans doute (au moins pour < et == ) appel aux membres de la classe, et les version sous forme de fonction libre feront appel à la version sous forme de fonction membre, sous une forme qui serait au final proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class MaClasse{ public: /* je ne met que celui- là pour l'exemple*/ bool operator ==(MaClasse const &) const; }; bool MaClasse::operator == (MaClasse const & other) const{ return this->membre1 == other.membre1 && this->membre2 == other.membre2; } bool operator(MaClasse const & c1, MaClasse const & c2){ return c1.operator==(c2); }
Il faut enfin savoir que les opérateurs prenant la forme de fonctions libres présentent de sérieux avantages, entre autres en termes de symétrie (par exempe : s'il existe une conversion possible entre un type quelconque et notre classe).

En effet, si on considère qu'il est possible de convertir implicitement un int en un objet du type MaClasse, un code proche de
Code:

1 2 3 4 5 6 int main(){ MaClasse c; if(c == 10) { // conversion implicite de 10 en un objet de type MaClasse /* ... */ } }
sera toujours autorisé, mais un code proche de
Code:

1 2 3 4 5 6 int main(){ MaClasse c; if(10 == c) { // conversion implicite de 10 en un objet de type MaClasse /* ... */ } }
ne sera autorisé que si l'opérateur existe sous la forme d'une fonction libre (et, bien sur, il en va de même pour tous les opérateurs de comparaison, ainsi que pour les opérateurs mathématiques, d'ailleurs)

Citation:
Envoyé par camboui
Je suggère d'écrire une fonction friend compare qui centralise la logique de comparaison de la classe/structure.
La surcharge des opérateurs souhaités est ensuite aisée.
Voici un exemple assez général:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class MyClass { std::string one; int two; //bazar_truc three; public: friend intptr_t compare(MyClass const & l, MyClass const & r) { intptr_t cmp = l.one.compare(r.one); if (cmp == 0) { cmp = (l.two - r.two); //if (cmp == 0) // cmp = compare(l.three, r.three); // etc... } return cmp; } };
J'aime bien l'idée.
Cependant, dans ton exemple, à la place de intptr_t, j'aurais mis intmax_t au cas où on ait sizeof(int) > sizeof(intptr_t).

La comparaison multi-membres peut également être fait à travers std::tie.

Code:

1
2
3
4
5
namespace detail {
  auto as_tuple(const T& o) { return std::tie(o.member1, o.member2);  }
}
bool operator==(const T& l, const T& r) { return detail::as_tuple(l) == detail::as_tuple(r); }
bool operator<(const T& l, const T& r) { return detail::as_tuple(l) < detail::as_tuple(r); }