调用超类方法运算符==

Question

我正在经历从Java到C++的转换，并试图编写一个简单的程序。

有一个超Animal具有以下inteface：

class Animal 
{ 
public: 
    Animal(int a, std::string n); 

    bool operator==(Animal a); 
private: 
    int age; 
    std::string name; 
}; 

而且它的子类Dog：

class Dog : public Animal 
{ 
public: 
    Dog(int a, std::string n, double w); 

    bool operator==(Dog d); 
private: 
    double weight; 

}; 

我的问题是关于狗的operator==方法，其中比较2只狗。

动物的operator==低于。

bool Animal::operator==(Animal a) //overriding of operator == 
{ 
return (age==a.age) && (name==a.name); 
} 

现在我想用Animal的方法编写狗的版本。

就像我在Java中做到：

boolean equals(Dog d){ 
    return (super.equals(d)) && (this.name==d.name); 
} 

我需要的是(super.equals(d)) C++的等价物。如果它是一个正常名称的方法，它会很容易（Animal :: equals（d）），但我不知道如何为operator ==操作，它有不同的语法。

Answer 1

这其实非常容易：

return Animal::operator==(d) && name==d.name; 

之所以使用超类的名称，而不是super的是，在C++中，你可以有多个超类，所以你必须要清楚你要哪一个。

或者，你可以通过使用它调用它的过载：

return ((Animal&)*this)==d && name==d.name; 

因为在这种情况下，paramters到operator==将是一个Animal&和Dog&，那么它无法比拟Dog::operator==(Dog d)，所以使用Animal::operator==(Animal a)代替。

注意：您的签名非常不寻常。相反，使用其中的一个：

bool operator==(const Animal& a) const; 
friend bool operator==(const Animal& left, const Animal& right); 

这些不要让动物的副本每次比较的时间，可以比较const动物。

Answer 2

您可以使用详细注释呼叫话务员：

operator==(const Dog& dog) { return Animal::operator==(dog) && weight==dog.weight; } 

Answer 3

你的Java equals的直接等同是：

bool Dog::operator==(Dog d) 
{ 
    return Animal::operator==(d) && weight == d.weight; 
} 

但我不知道这是你真正想要的。对于初学者， 你正在通过复制参数，这意味着你的 比较副本。特别是，当您拨打 Animal::operator==时，您将通过Animal部分 的Dog的副本，而不是完整的对象。班级类型通常是 通过引用传递;参考const如果你不想 修改它们。因此，在底部的签名会是这样 这样的：

bool Animal::operator==(Animal const& other) const 
{ 
    // ... 
} 

在 Dog

而与此类似。此外，Dog 中的比较运算符可能需要Animal const&，而不是Dog const&。 （在 的Java，equals需要java.lang.Object，永远。）这意味着 是你必须确认它是一个Dog：

bool Dog::operator==(Animal const& other) const 
{ 
    return dynamic_cast<Dog const*>(&other) != nullptr 
     && Animal::operator==(other) 
     && weight == other.weight; 
} 

编辑：

正如指出的评论，虽然这解决了 即时语法问题的原始海报，它不是 真的是我们通常这样做的方式。通常的解决办法 是这样的：

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); 
} 

的operator==实施和operator!=实际上可以 通过适当的类模板，它 避免了一些样板的继承来完成，如果你有很多的类 其中必须支持==和其他。