如何从基类构造函数调用派生类虚方法？

Question

class MyClass1
{
public:
  MyClass1()
  {
    init();
  }
  virtual void init()
  {
    printf("MyClass1 init");
  }
}

class MyClass2 : public MyClass1
{
public:
  virtual void init()
  {
    printf("MyClass2 init");
  }
}

int main()
{
  MyClass2 *obj = new MyClass2();
  return 0;
}

我希望这个结果

"MyClass2 init"

但它实际上显示了消息

"MyClass1 init"

如何从基类构造函数调用派生类虚方法？

=== 更新1 ===

class MyClass1
{
public:
  MyClass1()
  {
    init();
  }
  virtual void init()
  {
    printf("MyClass1 init");
  }
}

class MyClass2 : public MyClass1
{
public:
  MyClass2()
    : MyClass1()
  {
  }

  virtual void init()
  {
    printf("MyClass2 init");
  }
}

我希望 MyClass2 覆盖 MyClass1 初始化方法 但它仍然显示“MyClass1 init”

C++ 如何像 java/C# 覆盖方法一样工作？

=== 更新2 ===

class MyClass1
{
public:
  MyClass1()
  {
    init();   <--- can't work like test method ??? 
  }
  void test()
  {
    init();   <--- work fine
  }
  virtual void init()
  {
    printf("MyClass1 init");
  }
}

class MyClass2 : public MyClass1
{
public:
  MyClass2()
    : MyClass1()
  {
  }

  virtual void init()
  {
    printf("MyClass2 init");
  }
}

我知道 obj->init() 会调用 MyClass2::init。
但我希望 C++ 可以在 Constructor 方法中运行。

虽然 obj->init() 可以解决。
但是希望代码可以少写一点。
有些人忘记调用 init()。

Java/C# 可以少写多做。但是 C++ 不能……这很令人沮丧。

Answer 1

显然在MyClass2的构造过程中，MyClass1的构造函数会首先被调用， 那是派生类对象的基类部分在派生类部分之前构造。即使您明确尝试创建MyClass2 的对象，但在基类构造期间，虚函数永远不会进入派生类。

由于基类构造函数在派生类构造函数之前执行，派生类数据成员在基类构造函数运行时尚未初始化。如果在基类构造期间调用的虚函数下降到派生类，派生类函数几乎肯定会引用本地数据成员，但这些数据成员还没有被初始化，这将导致未定义的行为。

参考你的课程，为什么你首先有virtual init？构造函数应该分别完成工作。

如何从基类构造函数调用派生类虚方法？

这是个坏主意，永远不要这样做！

class MyClass1
{
public:
  virtual ~MyClass1() { }
  virtual void doSomething()
  {
    printf("MyClass1 init");
  }
};

class MyClass2 : public MyClass1
{
public:
  virtual void doSomething()
  {
    printf("MyClass2 init");
  }
};

int main()
{
  MyClass1*obj = new MyClass2();
  obj->doSomething();
  delete obj;
  return 0;
}

Answer 2

一般来说，你不能。那是因为MyClass2 构造函数还没有运行，所以如果MyClass2::init() 被调用，任何成员变量都将被取消初始化。在此构造函数启动之前，出于虚拟目的，该对象被视为MyClass1 实例。

例如：

class MyClass2 : public MyClass1
{
private:
    std::string xxx;
public:
    virtual void init()
    {
        xxx = "ops!"; //undefined if called from base class constructor
    }
};

对xxx 的赋值将呈现未定义的行为，因为它的构造函数尚未运行。

鉴于你没有结尾 ; 我猜你的背景是 Java/C#。这些语言以不同的方式实现了这个问题，但这正是 C++ 的工作原理。

Answer 3

我不确定这是否合法或将来可能会中断。但是，使用 lambda 函数，您可以将代码发送到基类以在构造函数期间执行。

class Base {
public:
    Base(std::function<void()> fnCall=nullptr) {
        if (fnCall) fnCall();
    }
    Base(const Base &base, std::function<void()> fnCall = nullptr) {
        DoSomethingAtBaseHere();
        if (fnCall) fnCall();
    }
};

class Derived: public Base {
public:
    Derived(std::function<void()> fnCall=nullptr) : Base([&]() {
        DoSomethingAtDerivedHere();
        if (fnCall) fnCall();
    }) {}
    Derived(const Derived &oth, std::function<void()> fnCall=nullptr) : 
    Base(oth, [&]() {
        DoSomethingInCopyConstructorAtDerivedHere();
        if (fnCall) fnCall();
    })  {}
};

Answer 4

我认为：
没有理由 C++ 不能做 java/C# 虚拟构造器机制。
我想打破 C++ 规则。
我也希望C++可以少写多做。
C++不进步就不会进步，让更多的人不容易入门。

class MyClass1
{
public:
  MyClass1()
  {
    init();
  }

  typedef void (MyClass1::virtual_init)();
  MyClass1(virtual_init vinit)
  {
    (this->*vinit)();
  }

  //virtual void init()
  void init()
  {
    printf("MyClass1 init");
  }
}

class MyClass2 : public MyClass1
{
public:
  MyClass2()
    : MyClass1(&MyClass2::init)
  {
  }

  //virtual void init()
  void init()
  {
    printf("MyClass2 init");
  }
}