調用超類方法運算符==

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!=實際上可以 通過適當的類模板，它 避免了一些樣板的繼承來完成，如果你有很多的類 其中必須支持==和其他。