关于C++的虚函数在父类的内部调用

Posted 2023-04-13

假设有class Base, Child
class Base

public:
virtual void Destroy(void) = 0;
void B(void)

Destroy();


~Base(void)

B();



class Child : public Base

public:
void Destroy(void)

//Do something....



为什么子类的Destroy函数不会被调用而出现了调用纯虚函数的错误呢？

在父类中声明了虚函数（包括纯虚函数），在子类构造时就会维护一个虚表。多态表现在如果父类中声明了一个方法是虚函数，子类在调用函数时会在虚表中看看自己有没有重载这个函数，如果没有就到父类中去找。
你的问题在于，父类中声明了一个纯虚函数，而这个纯虚函数又是在类的构造函数中产生。这样产生一个问题：当构造子类对象时，应该是先构造父类那部分，而系统调用父类构造函数时，发现构造函数里有纯虚函数，无法完成构造过程，所以提示调用纯虚函数的错误 参考技术A 父类里面不能调用子类的Destroy，父类的Destroy是纯虚的，
~Base(void)

B();

调用的是父类的virtual void Destroy(void) = 0;
但是它的纯虚的，不能调用。
所以报了错。本回答被提问者采纳

c++中的虚函数

父类 FC  FatherClass   子类 SC   SonClass

　　

一 ，虚函数

C++的虚函数主要作用是“运行时多态”，父类中提供虚函数的实现，为子类提供默认的函数实现。子类可以重写父类的虚函数实现子类的特殊化。

　　如下就是一个父类中的虚函数：

class FC
{
public:
    virtual void out2(string s)
    {
        cout<<"A(out2):"<<s<<endl;
    }
};

二 ，纯虚函数　　

　　C++中包含纯虚函数的类，被称为是“抽象类”。抽象类不能使用new出对象，只有实现了这个纯虚函数的子类才能new出对象。

　　C++中的纯虚函数更像是“只提供申明，没有实现”，是对子类的约束，是“接口继承”。

　　C++中的纯虚函数也是一种“运行时多态”。

　　如下面的类包含纯虚函数，就是“抽象类”：

class FC
{
public:
    virtual void out1(string s)=0;
    virtual void out2(string s)
    {
        cout<<"A(out2):"<<s<<endl;
    }
};

　三 ，普通函数

　　普通函数是静态编译的，没有运行时多态，只会根据指针或引用的“字面值”类对象，调用自己的普通函数。

　　普通函数是父类为子类提供的“强制实现”。

　　因此，在继承关系中，子类不应该重写父类的普通函数，因为函数的调用只和类对象的字面值有关。

实例

 

在类对象的定义中，有四种组合，

1. FC fc=new FC;
2. FC fc = new SC;
3. SC sc=new SC;
4. SC sc =new FC;

其中 4 是错误的，不允许将一个父类对象，赋值给子类对象。

但允许，将一个子类对象，赋值给父类对象，如1 中所示。

当然不，这里的列子 在3中也是不成立的，因为如果FC中包含纯虚函数，那么其实一个抽象类，不能使用抽象类来new 一个对象、

 

验证程序，如下：

 1 //============================================================================
 2 // Name        : vf.cpp
 3 // FCuthor      : lian
 4 // Version     :
 5 // Copyright   : Your copyright notice
 6 // Description : Hello World in C++, FCnsi-style
 7 //============================================================================
 8 
 9 #include <iostream>
10 using namespace std;
11 
12 
13 class FC
14 {
15 public:
16     virtual void out1()=0;  ///由子类实现
17     virtual ~FC(){};
18     virtual void out2() ///默认实现
19     {
20         cout<<"FC(out2)"<<endl;
21     }
22     void out3() ///强制实现
23     {
24         cout<<"FC(out3)"<<endl;
25     }
26 };
27 
28 class SC:public FC
29 {
30 public:
31     virtual ~SC(){};
32     void out1()
33     {
34         cout<<"SC(out1)"<<endl;
35     }
36     void out2()
37     {
38         cout<<"SC(out2)"<<endl;
39     }
40     void out3()
41     {
42         cout<<"SC(out3)"<<endl;
43     }
44 };
45 
46 int main()
47 {
48     FC *fs=new SC;
49     fs->out1();
50     fs->out2();
51     fs->out3();
52     cout<<"************************"<<endl;
53     SC *ss=new SC;
54     ss->out1();
55     ss->out2();
56     ss->out3();
57 
58     delete fs;
59     delete ss;
60     return 0;
61 }

在Line 51中 fs->out3,这里是普通函数，只会根据指针或引用的“字面值”类对象，调用自己的普通函数。

所以其调用父类的普通函数，输出 FC（out3）

 

 

程序的输出结果为

SC(out1)
SC(out2)
FC(out3)
************************
SC(out1)
SC(out2)
SC(out3)