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＆amp;）const'标记为'覆盖'，但不覆盖

这是面向对象语言的常规设计，请想象如下：

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

p->equal(p2);

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

如果要覆盖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

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

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

所以，问题：

我们应该如何计算ab？

好的，这很简单：point b object，因此我们致电a->object::equal(object const&)。
我们应该如何计算ba？

这很难。

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

或者我们可以写一个覆盖，所以我们调用b->point::equal(object const &)，让它决定它的参数对象是否真的一个point。（这是霍尔特的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之类的内容。随着子类数量的增长，代码不能很好地扩展，但是对于小案例来说，实现起来要比成熟的访问者简单得多。

我可以实现一个虚拟函数的覆盖，它将参数作为父类吗？

3 个答案: