我可以实现一个以父类为参数的虚函数的覆盖吗？

Question

我正在尝试在以下代码中覆盖equal 方法：

class object{
  int a;
public:
  virtual bool equal(const object& o) const{
    return this->a==o.a; // not sure if i can access private field (o.a) from one object function to the object o so it's another question
  }
};

class point: public object{
  double x;
  double y;
public:
  bool equal(const point& o) const override{
    return (this->x==o.x && this->y==o.y);
  }
};

我曾想过重载operator== 并将其用作friend 函数，但如果我能在这种情况下以某种方式实现它会对我有所帮助...

Answer 1

不，你不能，尝试添加override：

bool equal(const point& o) const override;

...你得到一个编译错误：

错误：'bool point::equal(const point&) const' 标记为'覆盖'，但没有覆盖

这是面向对象语言的正常设计，想象一下：

object *p = new point();
object p2;

p->equal(p2);

p->equal 会通过虚拟查找找到point::equal(point const&)，但p2 不是point，而是object，那么编译器应该怎么做？

如果您想覆盖equal，您可以执行以下操作：

bool equal(const object& o) const override {
    auto *p = dynamic_cast<const point*>(&o);
    if (!p) {
        return false;
    }
    return this->x == p->x && this->y == p->y;
}

...但也许您应该重新考虑您的设计而不是这样做？

Answer 2

如果更改 equal 方法的签名，它会隐藏父级而不是覆盖它。你可以这样做（提高效率的空间）：

#include <iostream>
#include <iomanip>

using std::cout;
using std::endl;
using std::boolalpha;

class object{
  int a;
public:
  object(int value) : a{value} {}
  virtual bool equal(object const& o) const {
    return typeid(*this) == typeid(o)
      && this->a == o.a;
  }
};

class point : public object {
  double x;
  double y;
public:
  point(int value, double xval, double yval) : object{value}, x{xval}, y{yval} {}
  bool equal(object const& o) const {
    return object::equal(o)
      && this->x == dynamic_cast<point const&>(o).x
      && this->y == dynamic_cast<point const&>(o).y;
  }
};

int main() {
  auto o1 = object{7};
  auto o2 = object{7};
  auto p3 = point{7, 8.0, 9.0};
  auto p4 = point{7, 8.0, 9.0};
  auto p5 = point{7, 8.1, 9.1};

  cout << boolalpha;
  cout << "o1 equal o2? " << o1.equal(o2) << "\n";
  cout << "o1 equal p3? " << o1.equal(p3) << "\n";
  cout << "p3 equal p4? " << p3.equal(p4) << "\n";
  cout << "p3 equal p5? " << p3.equal(p5) << "\n";
  cout << "o2 equal o1? " << o2.equal(o1) << "\n";
  cout << "p3 equal o1? " << p3.equal(o1) << "\n";
  cout << "p4 equal p3? " << p4.equal(p3) << "\n";
  cout << "p5 equal p3? " << p5.equal(p3) << "\n";
  cout << "---done---" << endl;
}

Answer 3

这在几个方面是有问题的。

首先，你现有的代码肯定不会工作，如果你试过编译器会告诉你的。

让我们看看原因

object a{42};
point b{1.2, 3.4};
bool ab = a.equal(b);
bool ba = b.equal(a);

所以，问题：

1. 我们应该如何计算ab？

   好的，这很简单：point b 是 object，所以我们称之为a->object::equal(object const&)。

2. 我们应该如何计算ba？

   这个更难。

   我们可以使用b->object::equal(object const &)，它的好处是对称（如果a.equal(b) == b.equal(a) 通常更好。

   或者我们可以写一个覆盖，所以我们调用b->point::equal(object const &)，并让它决定它的参数对象是否真的是point。 （这是 Holt 的 dynamic_cast 解决方案）。

对于最后一种情况，我们可以有一个重载（而不是覆盖），所以point 有两个equal 方法，一个采用object（这实际上可以是基类方法）和一个采用point。但是，这只适用于静态类型。

class point : public object{
  double x;
  double y;
public:
  bool equal(const point& o) const {
    return (this->x==o.x && this->y==o.y);
  }
  using object::equal; // stop this being hidden
};

现在我们有一个重载而不是覆盖（所以在这个阶段使用virtual 毫无意义），我们可以写

point c{5.6, 7.8};
bool ba = b.equal(a); // uses b->object::equal(object const&)
bool bc = b.equal(c); // uses b->point::equal(point const&)

但是，一旦我们开始存储基类指针或引用（这是首先使用virtual 的正常原因），我们就会丢失动态类型信息：

object &r = c;
bool br = b.equal(r); // uses object::equal(object const&)

如果您需要这种情况下使用动态类型（即，找出r 确实指的是point），您需要使用dynamic_cast 之类的东西。随着子类数量的增加，代码的扩展性不是很好，但是对于小案例来说，它比成熟的访问者实现起来要简单得多。