我们有，只是它不是一个构造函数:-)

struct A {
  virtual ~A() {}
  virtual A * Clone() { return new A; }
};

struct B : public A {
  virtual A * Clone() { return new B; }
};

int main() {

   A * a1 = new B;
   A * a2 = a1->Clone();    // virtual construction
   delete a2;
   delete a1;
}

虚函数基本上提供多态行为。也就是说，当您使用的对象的动态类型与引用它的静态(编译时)类型不同时，它提供的行为适合于对象的实际类型，而不是对象的静态类型。

现在尝试将这种行为应用于构造函数。当你构造一个对象时，静态类型总是与实际的对象类型相同，因为:

要构造一个对象，构造函数需要它要创建的对象的确切类型[…]此外[…]]则不能有指向构造函数的指针

Bjarne Stroustup (P424 c++编程语言SE)

我们有，只是它不是一个构造函数:-)

struct A {
  virtual ~A() {}
  virtual A * Clone() { return new A; }
};

struct B : public A {
  virtual A * Clone() { return new B; }
};

int main() {

   A * a1 = new B;
   A * a2 = a1->Clone();    // virtual construction
   delete a2;
   delete a1;
}

当人们问这样的问题时，我喜欢对自己说:“如果这真的是可能的，会发生什么?”我真的不知道这意味着什么，但我猜这可能与能够基于所创建对象的动态类型重写构造函数实现有关。

我看到了一些潜在的问题。首先，在调用虚构造函数时，派生类不会被完全构造，因此实现中存在潜在的问题。

其次，在多重继承的情况下会发生什么?你的虚构造函数可能会被多次调用，然后你需要有某种方法知道哪个被调用了。

第三，一般来说，在构造时，对象并没有完全构造虚拟表，这意味着需要对语言规范进行很大的更改，以允许在构造时就知道对象的动态类型。这将允许基类构造函数在构造时调用其他虚函数，使用未完全构造的动态类类型。

最后，正如其他人指出的那样，您可以使用静态的“create”或“init”类型函数实现一种虚拟构造函数，基本上与虚拟构造函数所做的事情相同。

When a constructor is invoked, although there is no object created till that point, we still know the kind of object that is gonna be created because the specific constructor of the class to which the object belongs to has already been called. Virtual keyword associated with a function means the function of a particular object type is gonna be called. So, my thinking says that there is no need to make the virtual constructor because already the desired constructor whose object is gonna be created has been invoked and making constructor virtual is just a redundant thing to do because the object-specific constructor has already been invoked and this is same as calling class-specific function which is achieved through the virtual keyword. Although the inner implementation won’t allow virtual constructor for vptr and vtable related reasons.

Another reason is that C++ is a statically typed language and we need to know the type of a variable at compile-time. The compiler must be aware of the class type to create the object. The type of object to be created is a compile-time decision. If we make the constructor virtual then it means that we don’t need to know the type of the object at compile-time(that’s what virtual function provide. We don’t need to know the actual object and just need the base pointer to point an actual object call the pointed object’s virtual functions without knowing the type of the object) and if we don’t know the type of the object at compile time then it is against the statically typed languages. And hence, run-time polymorphism cannot be achieved. Hence, Constructor won’t be called without knowing the type of the object at compile-time. And so the idea of making a virtual constructor fails.

我们不能简单地说…我们不能继承构造函数。因此没有必要将它们声明为虚拟的，因为虚拟提供了多态性。