解决这个问题的一个方法是使用工厂方法来创建对象。

为你的类层次结构定义一个公共基类，其中包含一个虚拟方法afterConstruction():

class Object
{
public:
  virtual void afterConstruction() {}
  // ...
};

定义一个工厂方法:

template< class C >
C* factoryNew()
{
  C* pObject = new C();
  pObject->afterConstruction();

  return pObject;
}

像这样使用它:

class MyClass : public Object 
{
public:
  virtual void afterConstruction()
  {
    // do something.
  }
  // ...
};

MyClass* pMyObject = factoryNew();

原因是c++对象的构造就像洋葱，由内而外。基类在派生类之前构造。所以，在生成B之前，必须先生成a。当调用A的构造函数时，它还不是B，因此虚函数表中仍然有A的fn()副本的条目。

虚表是由编译器创建的。 类对象有一个指向虚表的指针。当它开始生命时，虚表指针指向虚表 基类的。在构造函数代码的末尾，编译器生成重新指向虚表指针的代码 到类的实际虚函数表。这样可以确保调用虚函数的构造函数代码调用 这些函数的基类实现，而不是类中的重写。

正如已经指出的那样，对象是在构造时创建的。在构造基对象时，派生对象还不存在，因此虚函数重写不能工作。

然而，如果你的getter返回常量，这可以用多态getter来解决，多态getter使用静态多态性而不是虚函数，或者可以在静态成员函数中表示。本例使用CRTP (https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern)。

template<typename DerivedClass>
class Base
{
public:
    inline Base() :
    foo(DerivedClass::getFoo())
    {}

    inline int fooSq() {
        return foo * foo;
    }

    const int foo;
};

class A : public Base<A>
{
public:
    inline static int getFoo() { return 1; }
};

class B : public Base<B>
{
public:
    inline static int getFoo() { return 2; }
};

class C : public Base<C>
{
public:
    inline static int getFoo() { return 3; }
};

int main()
{
    A a;
    B b;
    C c;

    std::cout << a.fooSq() << ", " << b.fooSq() << ", " << c.fooSq() << std::endl;

    return 0;
}

通过使用静态多态性，基类知道在编译时提供信息时调用哪个类的getter。

作为补充，调用尚未完成构造的对象的虚函数也将面临同样的问题。

例如，在对象的构造函数中启动一个新线程，并将该对象传递给新线程，如果新线程在对象完成构造之前调用该对象的虚函数将导致意想不到的结果。

例如:

#include <thread>
#include <string>
#include <iostream>
#include <chrono>

class Base
{
public:
  Base()
  {
    std::thread worker([this] {
      // This will print "Base" rather than "Sub".
      this->Print();
    });
    worker.detach();
    // Try comment out this code to see different output.
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
  virtual void Print()
  {
    std::cout << "Base" << std::endl;
  }
};

class Sub : public Base
{
public:
  void Print() override
  {
    std::cout << "Sub" << std::endl;
  }
};

int main()
{
  Sub sub;
  sub.Print();
  getchar();
  return 0;
}

这将输出:

Base
Sub

你知道Windows资源管理器的崩溃错误吗?“纯虚函数调用…” 同样的问题…

class AbstractClass 
{
public:
    AbstractClass( ){
        //if you call pureVitualFunction I will crash...
    }
    virtual void pureVitualFunction() = 0;
};

由于pureVitualFunction()函数没有实现，并且在构造函数中调用该函数，因此程序将崩溃。