Re: operator==
Andrea Crotti <andrea.crotti.0@gmail.com> wrote:
Obviously, if there is a batch of code that all op== functions have in
common, then you should write a function that takes care of that, but it
need not be an op==.
Why shouldn't it be op==?
Because you explicitly said you would never be comparing two objects of
different derived types. Giving the base class an op== implies that you
might do that.
Anyway now my code doesn't segfault anymore, the only problem I have is
that it calls
operator== from
class Serializable
{
public:
Serializable() {}
virtual Stream toStream() const = 0;
virtual bool operator==(const Serializable& other) { return false; };
};
and the thing is that if I make it pure then I have to change all the
operator== in the subclasses of Serializable, otherwise the signature is
different.
That was what I was warning you about from the beginning. The signature
*is* different (whether the base class op== is pure virtual or not.)
Given something from
std::vector<Serializable *>
is it not possible to call the more specialized method of the object?
No, the compiler only checks the type of the left most object, the right
object is assumed to be a Serializable and so op==(const Serializable&)
is called every time which means (based on the code above,) that no two
Serializable objects are ever equal.
I mean if that pointer points to an object of a subclass of
Serializable, if I was able to call that operator== I would be fine and
everything would work...
Exactly why I told you your code wouldn't work.