Le langage C++ permet de surchargé les opérateurs ce qui permet de faire des opérations comme la comparaison entre des objets.

De plus comme la STL est bien implémenté il est possible aussi d’utilisé dans des conteneurs l’appel à la surcharge de l’opérateur de comparaison.

Comme d’habitude un exemple vaut mieux qu’un long discourt:

[sourcecode language="cpp"]#include <vector>
#include <iostream>

using namespace std ;

class A
{
int _a ;
public:
A( int a ) : _a(a) {}
virtual bool operator==(const A& p) const
{
return ( _a == p._a );
}
};

class B : public A
{
float _b ;
public:
B( int a, float b ) : A(a), _b(b) {}
virtual bool operator==(const A& p) const
{
if ( A::operator ==(p) != true )
return false ;
const B& pp = dynamic_cast<const B&>(p);
return ( _b == pp._b );
}
};

template<class T>
void print( const char* text, const T& p1, const T& p2 )
{
cout << text ;
try
{
if ( p1 == p2 )
cout << " => true" ;
else
cout << " => false" ;
} catch (…)
{
cout << " => Exception" ;
}
cout << endl;
}

int main()
{
B b1( 1, 1.1f );
B b2( 1, 1.1f );
print( "b1( 1, 1.1 ) == b2( 1, 1.1 )", b1, b2 );
B b3( 1, 1.2f );
print( "b1( 1, 1.1 ) == b3( 1, 1.2 )", b1, b3);
print( "b3( 1, 1.2 ) == b3( 1, 1.1 )", b3, b1);
A a1( 1 );
print<A>( "a1( 1 ) == b1( 1, 1.1 )", a1, b1 );
print<A>( "b1( 1, 1.1 ) == a1( 1 )", b1, a1 );

vector<B> vb1;
vb1.push_back( b1 );
vb1.push_back( b2 );
vb1.push_back( b3 );

vector<B> vb2;
vb2.push_back( b1 );
vb2.push_back( b2 );
vb2.push_back( b3 );

print("vb1 == vb2", vb1, vb2 );
print("vb2 == vb1", vb2, vb1 );

vb1[0] = b3 ;
print("vb1 == vb2", vb1, vb2 );
}[/sourcecode]

Sortie console :
[code]b1( 1, 1.1 ) == b2( 1, 1.1 ) => true
b1( 1, 1.1 ) == b3( 1, 1.2 ) => false
b3( 1, 1.2 ) == b3( 1, 1.1 ) => false
a1( 1 ) == b1( 1, 1.1 ) => true
b1( 1, 1.1 ) == a1( 1 ) => Exception
vb1 == vb2 => true
vb2 == vb1 => true
vb1 == vb2 => false[/code]