Virtual operator overloads don't seem to work

[ABHAYK]

#include <iostream>

using namespace std;

class Base{
public:
virtual void Test(){
cout << "Base" << endl;
}

virtual bool operator==(const Base &other){
cout << "Base Comparison" << endl;
return false;
}
};

class Derived : public Base{
public:
void Test(){
cout << "Derived" << endl;
}

bool operator==(const Derived &other){
cout << "Derived Comparison" << endl;
return true;
}
};

int main(int argc, char** argv) {
Base a; //Create a base object
a.Test(); //Outputs "Base" as expected
Derived b, c; //Create two derived objects
b.Test(); //Outputs "Derived" as expected
if(b==c) cout << "True" << endl; //Does derived comparison and
returns true as expected.
Base *d=&b, *e=&c; //Create two base pointers to derived objects
d->Test(); //Outputs "Derived" as expected
if(*d==*e) cout << "True" << endl; //Does base comparison and
returns false!?
return 0;
}

The output is:

Base
Derived
Derived Comparison
True
Derived
Base Comparison

Notice, that the line "d->Test()" works correctly, but the comparison on the next line does not. The compiler (g++ (GCC) 4.2.3 (Ubuntu 4.2.3-2ubuntu7) ) seems to be ignoring the virtual-ness of Base:perator== . Is this correct? Have I made a mistake?

[Gony]

binary operators don't work very well with inheritance; what you'd really need to make them work is double dispatch. In the special case of == and !=, you can do something like:

bool
Derived:perator==( Base const& other ) const
{
Derived const* p
= dynamic_cast< Derived const* >( &other ) ;
return p != NULL && operator==( *p ) ;
}

in addition to your normal Derived:perator==, at least if you decide that two different derived types can never compare equal. If it makes sense for two different derived types to compare equal, however (say because they both represent the same value, but in different ways), you'll need to set up a much more complicated mechanism.

[Boy_Genius]

You can do that with a free function:

bool operator==(const Derived& Left, const Base& Right)
{ return Right.operator==(Left); }