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)

[romainprogdebutant]

Merci Dragonjoker comme ça ça marche :

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
class ComparePair
{
	public:
	bool operator()(const pair<int,int>& a, const pair<int,int>& b) 
	{
 
		int 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,ComparePair> edge_map;

[JolyLoic]

Même si ça marche, je n'arrive pas à être convaincu que ce soit la bonne solution. std::pair est prévu pour avoir deux valeurs, un first et un second, ces deux valeurs n'ayant pas le même rôle. Ce n'est pas ça que tu veux. Et tordre std::pair pour le faire entrer dans ton moule ne me semble pas une bonne idée :
- Est-ce que tu es certain que nulle part tu ne vas utiliser la comparaison par défaut qui ne fait pas ce que tu veux ? Si tu as des arrêtes un jour dans un vector et que tu utilises std::find, ou std::sort... par exemple, ne risques tu pas d'oublier ?
- Quelqu'un qui va lire ton code ne risque-t-il pas de mal comprendre ?

Je pense qu'il serait préférable de créer une classe arrête qui ait le bon comportement et la bonne sémantique. C'est rapide à faire, et au final, je trouve ça bien plus propre.

[Médinoc]

En fait, je conseillerais une classe qui stocke toujours ses valeurs dans le même ordre; une représentation normalisée des arètes, en quelque sorte.

[ternel]

J'imagine que le problème est de n'avoir que des aretes uniques dans un graphe non orienté.
L'idée serait alors de savoir ordonner les noeuds (par ordre de création, par exemple), et de garantir que toute arete (A,B) est telle que A < B.

[Médinoc]

Possiblement un truc du genre:

Code C++ :

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

1
2
3
Arete::Arete(int noeudA, int noeudB)
 : noeudMin(min(noeudA, noeudB)), noeudMax(max(noeudA, noeudB))
{ }