C++ 纯虚函数的继承

有人能澄清这些概念并回答这些问题吗。先谢谢你

类A是一个基类，具有一个名为display的纯虚拟函数

class A 
{ 
  public:
       virtual void display()const=0;

};

类B是继承类a的派生类。此外，B覆盖显示功能

class B:public A 
{ 
  public:
       void display()const{cout<<"Always"<<endl;}

};

现在，我很清楚所有一级派生类（如B）都必须重写纯虚函数（来自类a），假设它们确实重写了它，那么如果有一个新的类C是从一级派生类（类B）派生的呢，它还需要重写纯虚拟函数（display）吗？还是不需要它，因为它在类B中被重写，而C继承B（从而接收display函数的重写）

Q1：现在B包含1个覆盖显示和1个继承的纯虚拟显示，对吗

我不知道你这是什么意思

C

不需要重写

display

。如果不重写，它将只使用从

B

继承的

Q1：现在B包含1个覆盖显示和1个继承的纯虚拟显示，对吗

我不知道你这是什么意思

C

不需要重写

display

。如果不重写，它将只使用从

B

继承的

假设有一个虚拟基类

a

它是否也需要覆盖纯虚拟功能（显示）

否，

C

从B获取所有函数，包括

display（）

但是，

C

可以选择再次重写

display（）

函数。依此类推。对类的子类化次数没有限制

假设有一个虚拟基类

a

它是否也需要覆盖纯虚拟功能（显示）

否，

C

从B获取所有函数，包括

display（）

但是，

C

可以选择再次重写

display（）

函数。依此类推。对类的子类化次数没有限制

Q1：现在B包含1个覆盖显示和1个继承的纯虚拟显示，对吗？或者纯虚拟显示由于覆盖而不存在

这里的第一个问题毫无意义。类

B

从

a

继承了一个纯虚拟，并覆盖了它。它也不“包含”

A:：display（）

确实存在，作为有效命名的实体，可以在

B

中引用。例如，如果定义了

A:：display（）

class A 
{ 
    public:
        virtual void display()const=0;
};

//   yes, defining a pure virtual function is allowed, albeit optional 
void A::display() const       
{
    std::cout << "A!\n";
}

因此在这种情况下，

A:：display（）

和

B:：display（）

都存在。无论是否定义了

A:：display（）

，上面的

B:：display（）

代码都将编译（因为编译器将

A:：display（）

和

B:：display（）

都识别为不同的函数名）。（如果未定义

A:：display（）

，链接器通常会报告缺少的符号）

问题2：假设B重写了显示函数，现在，如果有一个新类

class C:public B 
{ 
    public:
};

现在，我很清楚所有一级派生类（如B）都必须重写纯虚函数（来自类a），假设它们确实重写了它，那么如果有一个新的类C是从一级派生类（类B）派生的呢，它是否也需要重写纯虚拟函数（display），还是不需要，因为它在类B中被重写，而C继承了B（从而接收对display函数的重写）

如果

B

已重写

display（）

，则

C

将

display（）

继承为非纯虚拟函数。这意味着，如果

B

可以实例化，那么

C

也可以实例化

如果

C

没有覆盖继承的

display（）

，那么

一些display（）

将调用从

B

继承的版本，即

B:：display（）

如果

C

确实覆盖了

display（）

——这是任何继承的虚拟函数所允许的——那么它可以根据需要以任何方式实现

C:：display（）

Q1：现在B包含1个覆盖显示和1个继承的纯虚拟显示，对吗？或者纯虚拟显示由于覆盖而不存在

这里的第一个问题毫无意义。类

B

从

a

继承了一个纯虚拟，并覆盖了它。它也不“包含”

A:：display（）

确实存在，作为有效命名的实体，可以在

B

中引用。例如，如果定义了

A:：display（）

class A 
{ 
    public:
        virtual void display()const=0;
};

//   yes, defining a pure virtual function is allowed, albeit optional 
void A::display() const       
{
    std::cout << "A!\n";
}

因此在这种情况下，

A:：display（）

和

B:：display（）

都存在。无论是否定义了

A:：display（）

，上面的

B:：display（）

代码都将编译（因为编译器将

A:：display（）

和

B:：display（）

都识别为不同的函数名）。（如果未定义

A:：display（）

，链接器通常会报告缺少的符号）

问题2：假设B重写了显示函数，现在，如果有一个新类

class C:public B 
{ 
    public:
};

现在，我很清楚所有一级派生类（如B）都必须重写纯虚函数（来自类a），假设它们确实重写了它，那么如果有一个新的类C是从一级派生类（类B）派生的呢，它是否还需要覆盖纯虚拟功能（显示）或

class A 
{ 
    public:
        virtual void display()const=0;
};

//   yes, defining a pure virtual function is allowed, albeit optional 
void A::display() const       
{
    std::cout << "A!\n";
}

class B:public A 
{ 
   public:
       void display()const
       {
           A::display();
           std::cout<<"Always"<<endl;
       }
};

class C:public B 
{ 
    public:
};