关于C++：调用超类方法运算符==


Calling superclass method operator==

本问题已经有最佳答案，请猛点这里访问。

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

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

1
2
3
4
5
6
7
8
9
10
class Animal
{
public:
    Animal(int a, std::string n);

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

它是Dog的子类：

1
2
3
4
5
6
7
8
9
10
class Dog : public Animal
{
public:
    Dog(int a, std::string n, double w);

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

};

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

动物的operator==在下面。

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

现在我想用动物的方法写出狗的版本。

就像我在爪哇一样：

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

我需要的是EDCOX1(4)的C++等价物。如果它是一个具有普通名称的方法，那就很容易了(animal:：equals(d))，但是我不知道如何对operator==执行此操作，因为operator==具有不同的语法。

相关讨论

这其实非常简单：

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

使用超类的名称而不是EDCOX1(0)的原因是，C++中可以有多个超类，所以你必须弄清楚你想要哪一个。

或者，您可以通过使用超负荷来调用它：

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

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

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

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

它们不会在每次比较时复制动物，而且可以比较const种动物。

相关讨论

您的Java EDCOX1×7的直接等价物将是：

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

但我不确定这是否是你真正想要的。首先，你的论点是抄袭的，这意味着比较副本。尤其是你打电话的时候Animal::operator==号，您将通过一份Animal号零件的复印件。不是完整的对象。类类型通常是通过引用传递；如果不想传递，则引用const修改它们。所以底座上的签名像：

1
2
3
4
bool Animal::operator==( Animal const& other ) const
{
    //  ...
}

同样，在Dog中。另外，Dog中的比较运算符可能会用一个Animal const&，而不是Dog const&。中Java，EDCOX1，7，取EDCOX1，16，总是，这意味着你必须确认它是一个Dog：

1
2
3
4
5
6
bool Dog::operator==( Animal const& other ) const
{
    return dynamic_cast<Dog const*>( &other ) != nullptr
        && Animal::operator==( other )
        && weight == other.weight;
}

编辑：

正如在一条评论中指出的那样，虽然这说明了原始海报引发的即时语法问题，它不是真的像我们平时那样。通常的解决方案是像这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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!=实际上可以通过从适当的类模板继承来完成，该模板如果有很多类，就避免使用一些样板文件必须支持==等。

相关讨论

可以使用详细表示法调用运算符：

1
operator==(const Dog& dog) { return Animal::operator==(dog) && weight==dog.weight; }
相关讨论