Discussion :

[romainprogdebutant]

Bonjour,
Je souhaiterai savoir s'il est possible de surcharger l'opérateur == de la classe pair afin que par exemple une pair<1,2> soit équivalente à une pair<2,1>

Merci d'avance

[ternel]

Premièrement, histoire d'être bien certain, std::pair est une template de classe dont les deux arguments sont des types.

Pour tous types A et B, std::pair<A, B> est une classe, et std::pair<B, A> en est une autre.

Pour toutes classes Bidule et Machin, il est possible d'écrire les deux fonctions suivantes:

• [c]bool operator==(Bidule const&, Machin const&);[c],
• bool operator==(Machin const&, Bidule const&);.

Par exemple, ca pourrait donner:

Code :

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

1
2
3
4
template <typename A, typename B>
bool operator==(std::pair<A, B> const& a, std::pair<B, A> const& b){
    return (a.first==b.second) && (a.second==b.first);
}

Globalement, presque tous les opérateurs sont surchargeables par une fonction libre.
Les seules exceptions sont les opérateurs =, [] et ->.

[jo_link_noir]

=[/c], [] et ->.

+ (), cast et ->*

[romainprogdebutant]

Merci pour cete réponse, je vais préciser un peu plus le contexte parceque je crois que je suis à coté de la plaque.


En fait je souhaiterais créer une map<pair<int,int>,int> afin de lister les arrêtes d'un maillage 3D. la pair de int correspondra aux index des deux points 3d concernés. Le second argument int correspondra à l'index de l'arrête. Donc avec une arrête composée des points a et b,la pair<A,B> devrait être équivalente à une pair<B,A>. Seulement dans ma map si j'ai déjà une pair<a,b> l'ajout de pair <b,a> n'est pas considéré comme un doublon.

Je ne sais pas trop si je dois surcharger un opérateur et où le faire, je suis un peu perdu sachant que je ne maitrise pas trop le c++, plutôt habitué au Java où tout me parait plus fluide

[romainprogdebutant]

J'ai trouvé des pistes:
Premierement pour surcharger un opérateur il suffit de l'implementer dans un .h quelconque corrigez moi si je me trompe.

Deuxiemement, alors en fait la map n'utilise pas l'opérateur == pour identifier les doublons

Il existe néanmoins une règle à appliquer ! Car std::map n'utilise pas l'operator== pour savoir si une clef correspond à une autre ! il se dit que
!(a < b) && !(b < a)⇒ a == b

J'ai donc surcharger l'opérateur< en triant de cette façon : on cherche les plus grands nombres des deux pairs, on les compare, si il sont égaux on compare les deux autres nombres.
Exemple :
(10,2) est supérieur à (5,4) => car 10>5
(10,2) est inférieur à (10,11) => car 10<11

Cela donne donc :

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
template <typename T>
	bool operator<(const pair<T,T>& a, const pair<T,T>& b) 
    {
		T aSup, aInf, bSup, bInf;
		if(a.first<a.second){
			aSup = a.second;
			aInf = a.first;
		}else{
			aSup = a.first;
			aInf = a.second;
		}
		if(b.first<b.second){
			bSup = b.second;
			bInf = b.first;
		}else{
			bSup = b.first;
			bInf = b.second;
		}
		return (aSup!=bSup) ? (aSup<bSup) : (aInf < bInf);
    }

Cependant ma map ne tient pas compte de ma surcharge et utilise son operateur < de base . Ma map est donc toujours trier de façon classique

[dragonjoker59]

C'est parce qu'il faut specifier a ta map l'operateur de comparaison qu'elle doit utiliser:

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
 
template <typename T>
bool CompareEdges(const pair<T,T>& a, const pair<T,T>& b) 
{
	T aSup, aInf, bSup, bInf;
	if(a.first<a.second){
		aSup = a.second;
		aInf = a.first;
	}else{
		aSup = a.first;
		aInf = a.second;
	}
	if(b.first<b.second){
		bSup = b.second;
		bInf = b.first;
	}else{
		bSup = b.first;
		bInf = b.second;
	}
	return (aSup!=bSup) ? (aSup<bSup) : (aInf < bInf);
}
typedef std::map< std::pair< int, int >, int, &CompareEdges > edge_map;

(Non teste, a voir s'il faut pas ecrire ta fonction de comparaison en tant que foncteur)