Calling superclass method operator== [duplicate] - c++

Question

This question already has answers here:
How to call a parent class function from derived class function?
(7 answers)
Closed 8 years ago.
I'm going through a transition from Java to C++ and am trying to write a simple program.
There's a superclass Animal with the following inteface:
class Animal
{
public:
Animal(int a, std::string n);
bool operator==(Animal a);
private:
int age;
std::string name;
};
And it's subclass Dog:
class Dog : public Animal
{
public:
Dog(int a, std::string n, double w);
bool operator==(Dog d);
private:
double weight;
};
My question is in regards to the Dog's operator== method, which compares 2 dogs.
Animal's operator== is below.
bool Animal::operator==(Animal a) //overriding of operator ==
{
return (age==a.age) && (name==a.name);
}
Now I want to write the Dog's version using Animal's method.
Like I'd do in Java:
boolean equals(Dog d){
return (super.equals(d)) && (this.name==d.name);
}
What I need is the c++ equivalent of (super.equals(d)) . If it was a method with a normal name it would be easy(Animal::equals(d)), but I don't know how to do it for operator==, which has a diferent syntax.

Answer 1

It's actually surprisingly easy:
return Animal::operator==(d) && name==d.name;
The reason for using the superclass' name rather than super is that in C++ you can have multiple superclasses, so you have to be clear about which one you want.
Alternatively, you can call it via using it's overload:
return ((Animal&)*this)==d && name==d.name;
Since the paramters to operator== in this case would be an Animal& and a Dog&, then it can't match Dog::operator==(Dog d), and so uses Animal::operator==(Animal a) instead.
Note: Your signatures are highly unusual. Instead, use one of these:
bool operator==(const Animal& a) const;
friend bool operator==(const Animal& left, const Animal& right);
These don't make copies of animals each time you compare, and can compare const animals.

Answer 2

You can call the operator using verbose notation:
operator==(const Dog& dog) { return Animal::operator==(dog) && weight==dog.weight; }

Answer 3

The direct equivalent of your Java equals would be:
bool Dog::operator==(Dog d)
{
return Animal::operator==(d) && weight == d.weight;
}
But I'm not sure if this is what you really want. For starters,
you're taking the argument by copy, which means that your
comparing a copy. In particular, when you call
Animal::operator==, you will pass a copy of the Animal part
of Dog, not the complete object. Class types are usually
passed by reference; reference to const if you don't want to
modify them. So the signature in the base would be something
like:
bool Animal::operator==( Animal const& other ) const
{
// ...
}
And similarly in Dog. Also, the comparison operator in Dog
would probably take an Animal const&, not a Dog const&. (In
Java, equals takes a java.lang.Object, always.) Which means
that you'd have to verify that it was a Dog:
bool Dog::operator==( Animal const& other ) const
{
return dynamic_cast<Dog const*>( &other ) != nullptr
&& Animal::operator==( other )
&& weight == other.weight;
}
EDIT:
As was pointed out in a comment, while this addresses the
immediate syntax issue raised by the original poster, it isn't
really the way we'd do this normally. The usual solution would
be something like:
class Animal
{
// If Animal is actually an abstract class (usually the case
// in real code), this would be a pure virtual.
// Derived classes overriding this function are guaranteed
// that other is actually of the same type as they are,
// so they can just static_cast it to their type.
virtual bool doIsEqual( Animal const& other ) const
{
return true;
}
public:
bool isEqual( Animal const& other )
{
return typeid( *this ) == typeid( other )
&& // ... his local conditions...
&& doIsEqual( other );
}
};
bool operator==( Animal const& lhs, Animal const& rhs )
{
return lhs.isEqual( rhs );
}
bool operator!=( Animal const& lhs, Animal const& rhs )
{
return !lhs.isEqual( rhs );
}
The implementation of operator== and operator!= can in fact
be done by inheriting from an appropriate class template, which
avoids some of the boilerplate if you have a lot of classes
which must support == and the others.