Operator overloading for a hierarchy

[Gonçalo Rodrigues]

Hi all,

I could have sworn the c++ faq had the answer for this question but I
can't seem to find it, so here goes:

Suppose you have a single-rooted class hierarchy. Call the root class
Object. How can we provide operator overloading for the whole
hierarchy? e.g. provide == for the whole hierarchy?

Even more specifically: suppose we define

bool operator==(const Object* lhs, const Object* rhs) {
return lhs == rhs;
}

but we want to allow subclasses to override this behaviour by
overrididing some (virtual) method(s), so that even if you have only a
pointer to the base class (e.g. Object) the right comparison is made.
What is the best way to organize things?

TIA, best regards,
G. Rodrigues

 

[Noah Roberts]

Hi all,

I could have sworn the c++ faq had the answer for this question but I
can't seem to find it, so here goes:

Suppose you have a single-rooted class hierarchy. Call the root class
Object. How can we provide operator overloading for the whole
hierarchy? e.g. provide == for the whole hierarchy?

Even more specifically: suppose we define

bool operator==(const Object* lhs, const Object* rhs) {
return lhs == rhs;
}

but we want to allow subclasses to override this behaviour by
overrididing some (virtual) method(s), so that even if you have only a
pointer to the base class (e.g. Object) the right comparison is made.
What is the best way to organize things?

bool operator==(Object const& lhs, Object const& rhs) // use
references, not pointers
{
return lhs.equals(rhs); // call virtual equals function
}

The problem you may run into, and the answer depends highly on your
needs, is what if lhs and rhs are different eventual types.

 

[Victor Bazarov]

Hi all,

I could have sworn the c++ faq had the answer for this question but I
can't seem to find it, so here goes:

Suppose you have a single-rooted class hierarchy. Call the root class
Object. How can we provide operator overloading for the whole
hierarchy? e.g. provide == for the whole hierarchy?

Even more specifically: suppose we define

bool operator==(const Object* lhs, const Object* rhs) {

Huh? Pointers??

return lhs == rhs;
}

but we want to allow subclasses to override this behaviour by
overrididing some (virtual) method(s), so that even if you have only a
pointer to the base class (e.g. Object) the right comparison is made.
What is the best way to organize things?

class Object {
virtual bool operator ==(const Object& rhs) const;
};

class SomeOtherClass : public Object {
typedef Object base; // or whatever
virtual bool operator ==(const Object& rhs) const {
if (SomeOtherClass const *p = /* declare/define/init */
dynamic_cast<SomeOtherClass const*>(&rhs)) {
// do the comparison between '*this' and '*p'
}
else { // fall back onto Object
return this->base:perator==(rhs);
}
}
};

If you have a more sophisticated comparison, look up double dispatch.

V