C++进阶|多态知识点详解及经典面试题总结

基类对象的虚函数表中存放基类所有虚函数的地址。

派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表

指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基

类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴

的。

派⽣类中重写的基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函

数地址。

派⽣类的虚函数表中包含，基类的虚函数地址，派⽣类重写的虚函数地址，派⽣类⾃⼰的虚函数地

址三个部分。

虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后⾯放了⼀个0x00000000标

记。(这个C++并没有进⾏规定，各个编译器⾃⾏定义的，vs系列编译器会再后⾯放个0x00000000

标记，g++系列编译不会放)

虚函数存在哪的？虚函数和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函

数的地址⼜存到了虚表中。

虚函数表存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，vs下是存在代码段(常量区)。

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

class A
{
public:
virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;}
virtual void test(){ func();}
};
class B : public A
{
public:
void func(int val = 0){ std::cout<<"B->"<< val <<std::endl; }
};
int main(int argc ,char* argv[])
{
B*p = new B;
p->test();
return 0;
}

正确答案：B B->1

解析：

(1) 由于B类中没有覆盖（重写）基类中的虚函数test()，因此会调用基类A中的test();

(2)注意调用基类A中的test()时，由于this指针是A*类型的，在调用时就满足了基类指针指向子类对象的条件。
(3) A中test()函数中继续调用虚函数 fun()，因为虚函数执行动态绑定，p此时的动态类型（即目前所指对象的类型）为B*，因此此时调用虚函数fun()时，执行的是B类中的fun()；所以先输出“B->”；
(4) 缺省参数值是静态绑定，即此时val的值使用的是基类A中的缺省参数值，其值在编译阶段已经绑定，值为1，所以输出“1”；
最终输出“B->1”。

结论：（1）绝不重新定义继承而来的缺省参数值！

            （2）重写本质即重写函数体，函数头以基类中的虚函数为准。

2.

关于虚函数说法正确的是（ ）

A.被virtual修饰的函数称为虚函数

B.虚函数的作用是用来实现多态

C.虚函数在类中声明和类外定义时候，都必须加虚拟关键字

D.静态虚成员函数没有this指针

答案：B

解析：

A：被virtual修饰的成员函数称为虚函数

C：虚函数不能在类外定义实现

D:虚函数不可以是static类型，因为虚函数需要this指针调用，而static类型的函数无this指针。

静态成员函数：不属于类中的任何一个对象，属于类共有的一个函数。它无法用this指针来访问，因为this指针指向的是每一个对象和实例。

virtual虚函数：使用this指针。this指针调用vptr指针，指向虚函数列表，通过虚函数列表找到需要调用的虚函数的地址。总体来说虚函数的调用关系是：this指针->vptr(4字节）->虚函数列表 ->virtual虚函数。

因此，static静态函数没有this指针，就不能是虚函数。

3.

以下哪项说法时正确的（ ）

class A

{

public:

  void f1(){cout<<"A::f1()"<<endl;}

  virtual void f2(){cout<<"A::f2()"<<endl;}

  virtual void f3(){cout<<"A::f3()"<<endl;}

};



class B : public A

{

public:

  virtual void f1(){cout<<"B::f1()"<<endl;}

  virtual void f2(){cout<<"B::f2()"<<endl;}

  void f3(){cout<<"B::f3()"<<endl;}

};

A.基类和子类的f1函数构成重写

B.基类和子类的f3函数没有构成重写，因为子类f3前没有增加virtual关键字

C.基类引用引用子类对象后，通过基类对象调用f2时，调用的是子类的f2

D.f2和f3都是重写，f1是重定义

答案：D

解析：

对于f1，由于基类中的f1没有被virtual关键字修饰，不是虚函数。所以不满足重写条件。但因为函数名相同，且在继承体系中，满足隐藏即重定义。

对于f2,f3,基类中的f2,f3被virtual关键字修饰，是虚函数。至于子类当中的f2,f3无论是否被virtual修饰，都已经是虚函数。满足重写条件。

4.

关于抽象类和纯虚函数的描述中，错误的是 （ ）

A.纯虚函数的声明以“=0;”结束

B.有纯虚函数的类叫抽象类，它不能用来定义对象

C.抽象类的派生类如果不实现纯虚函数，它也是抽象类

D.纯虚函数不能有函数体

答案：D

解析：

A纯虚函数的声明以“=0;”结束

B有纯虚函数的类叫抽象类，它不能用来定义对象

C子类不实现父类所有的纯虚函数，则子类还属于抽象类，仍然不能实例化对象

D纯虚函数能有函数体，只是没有意义而已。因为抽象类无法实例化，根本不能调用纯虚函数。

5.

关于虚表说法正确的是（ ）

A.一个类只能有一张虚表

B.基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表

C.虚表是在运行期间动态生成的

D.一个类的不同对象共享该类的虚表

答案：D

解析：

A一个类中有几个虚函数就有几个虚表

B基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类仍然会有一张属于自己的虚表，内容与基类虚表相同

C虚函数表里的内容是在编译时期由编译器生成的

D.一个类的不同对象共享该类的虚表

6.

下面函数输出结果是（ ）

class A
{
public: 
  virtual void f()
  {
    cout<<"A::f()"<<endl;
  }
};

class B : public A
{
private:
   virtual void f()
  {
    cout<<"B::f()"<<endl;
  }
};

A* pa = (A*)new B;
pa->f();

A.B::f()

B.A::f()，因为子类的f()函数是私有的

C.A::f()，因为强制类型转化后，生成一个基类的临时对象，pa实际指向的是一个基类的临时对象

D.编译错误，私有的成员函数不能在类外调用

答案：A

解析：

B.虽然子类函数为私有，但是多态仅仅是用子类函数的地址覆盖虚表，最终调用的位置不变，只是执行函数发生变化

C.不强制也可以直接赋值，因为赋值兼容规则作出了保证

D.编译正确

7.

以下程序输出结果是( )

class A
{
public:
  A ():m_iVal(0){test();}
  virtual void func() { std::cout<<m_iVal<<‘ ’;}
  void test(){func();}
public:
  int m_iVal;
};


class B : public A
{
public:
  B(){test();}

  virtual void func()
  {
    ++m_iVal;
    std::cout<<m_iVal<<‘ ’;
  }
};

int main(int argc ,char* argv[])
{
  A*p = new B;
  p->test();
  return 0;
}

A.1 0

B.0 1

C.0 1 2

D.2 1 0，

答案：C

解析：

多态中，派生类初始化顺序如下：

1.构造父类；
2. 将子类虚函数表地址给子类对象；
3. 初始化列表进行初始化；
4. 构造函数本体；

（1）创造新的B对象时，先调用A的构造函数，在test函数中又调用了func函数，这个时候由于派生类的构造函数初始化列表还没走完，所以没有虚表指针不构成多态，只能调用A类中的func打印0。

（2）然后进入B类的构造函数的函数体中调用test函数，由于B中无test函数只能去父类A中调用，在A类中的test函数体中调用func函数，这个时候因为派生类的初始化列表已经走完了，虚表指针也形成了，并且func被子类重写由this指针也就是A*父类指针调用func满足多态，所以在B类中的func中先让mval++变成1然后打印1

（3）接下来由父类指针P主动调用test函数，同样满足多态调用B类中的func函数，mval++变成2然后打印2，所以答案是0 1 2.

8.

假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ ）

A.A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址

B.A类对象和B类对象前4个字节存储的都是虚表的地址

C.A类对象和B类对象前4个字节存储的虚表地址相同

D.A类和B类中的内容完全一样，但是A类和B类使用的不是同一张虚表

答案：B

解析：

A.A类对象和B类对象前4个字节存储的都是虚表的地址

C.A类和B类是不同的类如果都有虚函数各自有各自的虚表,地址不同

D.A类和B类不是同一个类，内容一定不同