Question

我是c ++的初学者，我发现了一些奇怪的东西并且无法理解无法在互联网上找到任何东西，所以想在这里问一下。我看到的代码是：

#include<iostream>
using namespace std;

class A 
{
    protected : int a;
    public:
        A(int a) 
        {
            this -> a = a;
        }
    virtual void foo() 
    {
        cout<<"A =" <<a <<endl;
    }
};

class B: public A 
{
    public: B(int b): A(b + 1) {}
    virtual void foo() 
    {
        cout<<"B =" <<a <<endl;
    }
};

int main(int argc, char * * argv)
{
    A * a = new B(1);
    a -> foo();
    return 0;
}

向我创建问题的行是派生类中的public: B(int b): A(b + 1) {}。我可以观察到继承基类构造函数及其输出的Derived类是B=2。有人可以详细解释一下它是如何成为可能的吗？在A * a =新B（1）;这里＆＃34; 1＆＃34;作为对象传递，并通过继承A(b + 1) {}行中的A class在public: B(int b): A(b + 1) {}构造函数中增加其值。

Answer 1

这是更详细的必要，但我们走了。

A * a = new B(1);

这一行创建一个新的B对象，将1传递给它的构造函数。

class B: public A 
{
    public: B(int b): A(b + 1) {}

构造函数接收1，然后使用b + 1（2）

调用A基础构造函数

A(int a) 
{
  this -> a = a;
}

A的构造函数将a设置为2。

因为您在virtual上使用了foo()关键字，所以您说：＆＃34;嘿编译器，对此函数调用使用动态绑定。＆＃34;这意味着如果a是A，则会调用A::foo。如果a是B（＆＃34;隐藏＆＃34;在其基本类型A中），则编译器将调用B::foo。

A * a = new B(1);

B对象可以存在于A对象中的事实是＆＃34;多态对象＆＃34;的概念。 virtual关键字告诉编译器将函数调用分派给A::foo或B::foo的事实是＆＃34;动态绑定＆＃34;或＆＃34;功能多态性＆＃34;。

a -> foo();

这里我们看到动态绑定在行动中。调用B :: foo（）返回B = 2

Answer 2

此记录

public: B(int b): A(b + 1) {}

并不意味着基础构造函数的继承。它意味着在派生类构造函数的mem-initializer列表中调用基类构造函数。

例如，你可以重写A类的构造函数

    A(int a) 
    {
        this -> a = a;
    }

以下方式

    A(int a) : a( a ) 
    {
    }

这并不意味着A类继承了int a。这意味着数据成员a由参数a。

初始化

Derived类构造函数可以在c ++中继承基类构造函数吗？

2 个答案: