有趣的 C++ 抽象函数

Question

为什么会发生这种情况？

当你在c++中创建抽象类时：Class A（它有一个纯虚函数） 之后类B继承自类A

并且如果类A有名为A()的构造函数 假设我创建了B类的对象，那么编译器首先初始化基类，即A类，然后初始化B类< /strong> 然后……？

首先，我们无法在没有对象的情况下访问任何类的构造函数，那么如果我们无法创建抽象类的对象，那么如何初始化抽象类的构造函数。

Answer 1

快速回答：构造函数很特殊。

当 A 的构造函数仍在运行时，正在构造的对象还不是真正的 A 类型。它仍在构造中。 当构造函数完成后，它现在是一个 A。

派生的 B 也是如此。A 的构造函数首先运行。 现在它是 A。然后 B 的构造函数开始运行。 在此期间，该对象实际上仍然是 A。只有当 B 的构造函数完成时，它才会变成 B。

您可以通过尝试从构造函数中调用纯虚函数来验证这一点。 如果该函数在 A 中定义，并且 B 的构造函数调用它，则会出现运行时错误，而不是运行 B 的重写，因为该对象还不是 B 类型。

由于纯虚函数，编译器将不允许您生成构造 A 的代码。 但它会生成代码来构造 A，作为构造 B 过程的一部分。这并不涉及任何魔法。 不能构造 A 的规则是由语言规则强加的，而不是由物理学强加的。 语言在构造 B 对象的特殊情况下解除了这一规则。

Answer 2

类 A 是抽象的，但 类 B 不是。 为了构造类B，它必须实现类A的所有纯虚成员函数。

class A
{
public:
    A() {}
    virtual ~A() {}
    virtual void foo() = 0; // pure virtual
    int i;
};


class B : public A
{
public:
    B() {}
    virtual ~B() {}
    virtual void foo() {}
    int j;
};

A 类布局可能是这样的：

+---------+     +---------+
| vftable | --> | ~A()    | --> address of A::~A()
+---------+     +---------+
| i       |     | foo()   | --> NULL, pure virtual
+---------+     +---------+

B 类布局可能是这样的：

+---------+     +---------+
| vftable | --> | ~B()    | --> address of B::~B()
+---------+     +---------+
| i       |     | foo()   | --> address of B::foo()
+---------+     +---------+
| j       |
+---------+

Answer 3

struct A {
  A(int x) {..}
  virtual void do() = 0;
};

struct B : public A {
   B() : A(13) {}      // <--- there you see how we give params to A c'tor
   virtual void do() {..}
};

Answer 4

 And if class A has constructor called A() suppose i created an
 Object of class B then the compiler initializes the base class
 first i.e.class A and then initialize the class B
 Then.......?

实际上你的做法是错误的：

当你创建 B 类的对象时，B 的构造函数被调用。
如果您不指定 B 构造函数如何调用 A 构造函数，则编译器将自动插入对 A 的默认构造函数的调用作为初始值设定项列表中的第一个操作。

如果您不想使用默认构造函数，则必须显式放置调用适当的 A 构造函数作为初始值设定项列表中的第一个元素。

当A的建设完成后，B的建设将继续进行。

First thing is we can not access a constructor of any class without an Object
then how it is initialize the constructor of abstract class if we can not create
an object of abstract class .

你说上面的话就好像你认为 A 和 B 是不同的东西一样。 B 类的对象也是 A 类的对象。对象作为一个整体才是有效的。 整个对象属于 B 类，但它包含（作为同一对象的一部分）来自 A 类的所有信息。

Answer 5

不能直接实例化类 A 并不意味着无法实例化类 A。 不允许您实例化 A，因为编译器知道 A 是抽象的，并拒绝您编写的任何尝试直接实例化 A 的代码。 它禁止这样的代码：

A a;
new A();

类之所以抽象是因为它具有纯虚方法。 不过，没有什么本质上可以阻止此类的实例化。 C++ 标准只是说这是不允许的。 编译器完全能够生成实例化抽象类的指令。 它所要做的就是保留适量的内存，然后调用构造函数，就像非抽象类一样。

当您实例化 B 时，该类的所有内存都会立即分配。 由于所有字节都在那里，因此本质上有一个 A 实例，准备好由构造函数初始化。 （但请注意，在 A 构造函数完成运行之后之前，内存不会被正式视为 A 类型的对象。） >A 构造函数运行，然后 B 构造函数运行。