Discussion :

[CANADG]

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 .

[Bktero]

Bonjour,

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

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

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

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

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

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.

[Bousk]

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 :

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

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

[camboui]

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

Code :

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

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

[CANADG]

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 :

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

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 :

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

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 ?

[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

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 ?

[CANADG]

@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

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

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 ?

exactement l'utilisation de l'objet local this est obligatoire je ne vois pas pourquoi mais c'est bien le cas.

[Pyramidev]

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 :

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

[jo_link_noir]

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

Code :

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

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