Question

我正在经历从Java到C ++的过渡，我正在尝试编写一个简单的程序。

有一个超类Animal具有以下接口：

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;

使用超类的原因＆＃39;名称而不是super是在C ++中你可以有多个超类，所以你必须清楚你想要哪一个。

或者，您可以通过使用它的超载来调用它：

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

由于在这种情况下operator==的参数为Animal&和Dog&，因此它不能与Dog::operator==(Dog d)匹配，因此使用{{ 1}}而不是。

注意：您的签名非常不寻常。相反，请使用以下方法之一：

Animal::operator==(Animal a)

每次比较时都不会复制动物，可以比较bool operator==(const Animal& a) const; friend bool operator==(const Animal& left, const Animal& right);只动物。

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!=的实施可以实现通过继承适当的类模板来完成如果您有很多课程，请避免使用某些样板文件必须支持==和其他人。

调用超类方法运算符==

3 个答案: