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.

If you think logically about how constructors work and what the meaning/usage of a virtual function is in C++ then you will realise that a virtual constructor would be meaningless in C++. Declaring something virtual in C++ means that it can be overridden by a sub-class of the current class, however the constructor is called when the objected is created, at that time you cannot be creating a sub-class of the class, you must be creating the class so there would never be any need to declare a constructor virtual.

另一个原因是，构造函数的名字与其类名相同如果我们将构造函数声明为virtual，那么它应该在它的派生类中以相同的名字重新定义，但两个类的名字不能相同。所以不可能有一个虚拟构造函数。

总结:c++标准可以为“虚拟构造函数”指定一种表示法和行为，这是相当直观的，而且编译器也不难支持，但是为什么在已经可以使用create() / clone()清晰地实现功能的情况下(见下文)，还要专门为此做出标准更改呢?它远不如正在酝酿中的许多其他语言提案那么有用。

讨论

让我们假设一个“虚拟构造函数”机制:

Base* p = new Derived(...);
Base* p2 = new p->Base();  // possible syntax???

在上面的代码中，第一行构造了一个Derived对象，因此*p的虚拟调度表可以合理地为第二行提供一个“虚拟构造函数”。(本页上有几十个回答说“这个物体还不存在，所以虚拟构建是不可能的”，这些答案都是不必要的短视地关注即将被构建的物体。)

第二行假设符号new p->Base()请求动态分配和另一个派生对象的默认构造。

注:

the compiler must orchestrate memory allocation before calling the constructor - constructors normally support automatic (informally "stack") allocation, static (for global/namespace scope and class-/function-static objects), and dynamic (informally "heap") when new is used the size of object to be constructed by p->Base() can't generally be known at compile-time, so dynamic allocation is the only approach that makes sense it is possible to allocate runtime-specified amounts of memory on the stack - e.g. GCC's variable-length array extension, alloca() - but leads to significant inefficiencies and complexities (e.g. here and here respectively) for dynamic allocation it must return a pointer so memory can be deleted later. the postulated notation explicitly lists new to emphasise dynamic allocation and the pointer result type.

编译器需要:

通过调用隐式的虚拟sizeof函数或通过RTTI获得这些信息，找出Derived需要多少内存 调用operator new(size_t)来分配内存 调用Derived()，位置为new。

OR

为结合了动态分配和构造的函数创建额外的虚表项

因此，指定和实现虚拟构造函数似乎并不是不可克服的，但最重要的问题是:它如何比使用现有的c++语言特性更好?就我个人而言，我认为下面的解决方案没有任何好处。

' clone() '和' create() '

c++常见问题解答文档中记录了一个“虚拟构造函数”习语，包含了用于默认构造或复制构造一个新的动态分配对象的虚拟create()和clone()方法:

class Shape {
  public:
    virtual ~Shape() { } // A virtual destructor
    virtual void draw() = 0; // A pure virtual function
    virtual void move() = 0;
    // ...
    virtual Shape* clone() const = 0; // Uses the copy constructor
    virtual Shape* create() const = 0; // Uses the default constructor
};
class Circle : public Shape {
  public:
    Circle* clone() const; // Covariant Return Types; see below
    Circle* create() const; // Covariant Return Types; see below
    // ...
};
Circle* Circle::clone() const { return new Circle(*this); }
Circle* Circle::create() const { return new Circle(); }

也可以更改或重载create()以接受参数，不过为了匹配基类/接口的虚函数签名，重写的参数必须精确匹配基类重载中的一个。有了这些用户提供的显式功能，添加日志记录、检测、更改内存分配等就变得很容易了。

有一个非常基本的原因:构造函数实际上是静态函数，而在c++中没有静态函数可以是虚函数。

如果你有丰富的c++经验，你就会知道静态函数和成员函数之间的区别。静态函数与CLASS相关联，而不是与对象(实例)相关联，因此它们看不到“this”指针。只有成员函数可以是虚函数，因为虚表——使“虚”工作的函数指针的隐藏表——实际上是每个对象的数据成员。

构造函数的任务是什么?它在名称中——“T”构造函数在分配T对象时初始化它们。这将自动排除它成为成员函数!对象必须先存在，然后才有this指针，从而有虚表。这意味着即使语言将构造函数视为普通函数(它并没有，由于相关原因，我不会深入讨论)，它们也必须是静态成员函数。

了解这一点的一个好方法是查看“Factory”模式，特别是工厂函数。它们做你想做的事情，你会注意到，如果类T有一个工厂方法，它是ALWAYS STATIC。这是必须的。

c++中的虚函数是运行时多态性的一种实现，它们将执行函数覆盖。在c++中，当需要动态行为时，通常使用virtual关键字。只有当对象存在时，它才会工作。而构造函数用于创建对象。构造函数将在对象创建时调用。

因此，如果您将构造函数创建为virtual，根据virtual关键字定义，它应该有现有的对象可以使用，但构造函数用于创建对象，因此这种情况将永远不存在。所以你不应该将构造函数作为虚函数使用。

因此，如果我们试图声明虚拟构造函数编译器抛出一个错误:

构造函数不能声明为虚函数

尽管由于对象类型是对象创建的先决条件，所以虚拟构造函数的概念不太适合，但它并没有完全被推翻。

GOF的“工厂方法”设计模式利用了虚拟构造函数的“概念”，这在某些设计情况下很方便。