2

我有这样的事情:

#include <iostream>

class X;

class A {
public:
  virtual void bar(X &x);
};

class B : public A {
public:
};

class X {
public:
  void foo(A &a) { std::cout << "foo A" << std::endl; }
  void foo(B &b) { std::cout << "foo B" << std::endl; }
};

void A::bar(X &x) { x.foo(*this); }

int main(int argc, char **argv) {
  X x;
  B b;
  b.bar(x);
  return 0;
}

编译并执行它,你将拥有:

# ./a.out
foo A
#

我相信这是因为对象在投射到 A 时被切片。我怎样才能避免这种情况,所以我得到

foo B

没有在 B 中实现该方法或使用一些奇怪的东西,比如Curiously recurring 模板模式

4

1 回答 1

5

这里没有进行切片,因为您小心地通过引用传递对象;切片需要按值操作对象。

效果是由于重载决议,它是静态完成的(即在编译时)。当 C++ 编译这个成员函数时

void A::bar(X &x) {
    x.foo(*this);
}

它需要在编译时决定选择两个重载中的哪一个。决定很简单:编译器知道它*this是 type A,所以它调用void foo(A &a)函数。

B如果不在*中实现相同的方法、使用模板或使用函数对象或 lambda 实现您自己的调度方案,您将无法使其工作。

*在这种情况下,您最终会得到一个几乎经典的 C++ 实现的访问者模式,这是一种实现Double Dispatch的技术。

于 2015-04-07T09:41:48.627 回答