序言：

在上期，我们对多态进行了详细的讲解。本期，我给大家带来的是关于有关多态常见的笔试和面试问题，帮助大家理解记忆相关知识点。

目录

（一）概念查考

（二）问答题

1、简述一下 C++ 中的多态

2、什么是重载、重写(覆盖)、重定义(隐藏)？

3、C++ 的重载和重写是如何实现的

4、inline函数可以是虚函数吗？

5、静态成员可以是虚函数吗？

6、为什么要虚析构，而不能虚构造？

7、对象访问普通函数快还是虚函数更快？

8、虚函数表里存放的内容是什么时候写进去的？

9、C++ 中哪些函数不能被声明为虚函数？

（一）概念查考

• A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定

【答案】：D

• A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复 用，也称为白盒复用
• B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动 态复用，也称为黑盒复用
• C：优先使用继承，而不是组合，是面向对象设计的第二原则
• D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封 装性的表现

【答案】：C

在面向对象设计中，并没有规定继承应该优先于组合。事实上，面向对象设计原则中的一个重要原则是「优先使用组合，而不是继承」，也被称为组合优于继承原则

这个原则建议使用组合（或聚合）关系来构建对象之间的关联，而不是过度使用继承。通过组合，可以更灵活地构建对象之间的关系，避免了过度依赖继承关系导致的紧耦合和复杂性增加。

因此，选项C中的说法是错误的。

• A：声明纯虚函数的类不能实例化对象
• B：声明纯虚函数的类是虚基类
• C：子类必须实现基类的纯虚函数
• D：纯虚函数必须是空函数

【答案】：A

纯虚函数是在基类中声明的虚函数，它没有提供默认的实现，而是由派生类来实现。这个函数在基类中被声明为纯虚函数，可以通过在函数声明的末尾使用 "= 0" 来表示。

根据C++语言规范，含有纯虚函数的类被称为抽象类，不能被直接实例化对象。只能通过派生类来创建对象，派生类需要实现基类中的纯虚函数，才能够被实例化。

选项B、C、D的说法是不正确的：

• B：声明纯虚函数的类并不一定是虚基类，虚基类是指在多重继承中被标记为虚继承的类。
• C：子类可以选择是否实现基类的纯虚函数，如果子类不实现基类中的纯虚函数，则它也会成为一个抽象类，不能直接实例化对象。
• D：纯虚函数可以有自己的实现代码，不一定是空函数。只要在基类中将该函数声明为纯虚函数即可。

4.关于虚函数的描述正确的是( )

• A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型
• B：内联函数不能是虚函数
• C：派生类必须重新定义基类的虚函数
• D：虚函数可以是一个static型的函数

【答案】：B

选项A是错误的描述。派生类的虚函数与基类的虚函数具有相同的参数个数和类型。在C++中，虚函数实现了动态绑定，允许基类指针或引用在运行时动态地调用派生类的虚函数。

选项C也是错误的描述。派生类不一定必须重新定义基类的虚函数。如果派生类没有重新定义基类的虚函数，那么它将继承基类的虚函数实现。

选项D也是错误的描述。虚函数不能是一个static型的函数。虚函数通过对象的动态类型来确定调用的函数，而static函数是与类本身相关联的，不涉及对象的特定实例。

因此，正确的描述是 B：内联函数不能是虚函数。

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

• A：一个类只能有一张虚表
• B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
• C：虚表是在运行期间动态生成的
• D：一个类的不同对象共享该类的虚表

【答案】：D

A：一个类的每个实例都有自己的虚函数表指针（vptr），即每个对象都有一个指向虚函数表的指针。每个类只有一个虚函数表，但每个对象都有自己的vptr，可以指向该类的虚函数表。

B：当派生类继承基类的虚函数并在派生类中没有重写时，子类将共享基类的虚函数表，并且派生类对象的vptr指针将指向基类的虚函数表。

C：虚表是在编译阶段由编译器生成的静态数据结构。编译器根据类的层次结构和虚函数的声明创建虚函数表，并在每个对象的vptr中存储对应的虚函数表。

因此，选项 B、C 和 A 都是错误的。只有选项 D 是正确的，即一个类的不同对象共享该类的虚表。

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

• A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
• B：A类对象和B类对象前4个字节存储的都是虚基表的地址
• C：A类对象和B类对象前4个字节存储的虚表地址相同
• D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

【答案】：D

在这种情况下，类A和类B各自会有自己的虚函数表，虽然它们的虚函数个数相同，但它们使用的是不同的虚表。类B继承自类A，当类B重写了类A中的虚函数时，会在类B的虚函数表中将该虚函数替换为类B的实现。因此，类A和类B的虚表中存储的是不同的虚函数的地址。

选项A、B和C均与这种情况不符，因此是错误的。正确选项是D。

7.下面程序输出结果是什么? （）

class A{
public:A(char *s) { cout<<s<<endl; }~A(){}
};
class B:virtual public A
{
public:B(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};
class C:virtual public A
{
public:C(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};
class D:public B,public C
{
public:D(char *s1,char *s2,char *s3,char *s4):B(s1,s2),C(s1,s3),A(s1){ cout<<s4<<endl;}
};
int main() {D *p=new D("class A","class B","class C","class D");delete p;return 0;
}

• A：class A class B class C class D
• B：class D class B class C class A
• C：class D class C class B class A
• D：class A class C class B class D

【答案】：A

首先，通过创建D类的对象p并传递相应的字符串参数，会触发类的构造函数的调用。因为D类是继承自B和C类，并且B和C类都是虚继承自A类的，所以在创建D对象时，会按照虚继承的顺序先调用A类的构造函数。因此，首先输出 "class A"。

接下来，B类和C类的构造函数会被调用，分别输出 "class B" 和 "class C"。

最后，D类自身的构造函数被调用，输出 "class D"。

在程序结束时，会执行delete操作释放对象p所占用的内存，同时会按照与构造函数相反的顺序调用析构函数，所以会先输出 "class D"、"class C"、"class B"、"class A"。

include<iostream>
using namespace std;int Add(int a,int b)//1
{return a+b;
}
char Add(char a,char b)//2
{return a+b;
}
int main()
{cout<<Add(666,888)<<endl;//1cout<<Add('1','2');//2return 0;
}

class Base {
public:virtual inline void foo() {cout << "Base::foo()" << endl;}
};class Derived : public Base {
public:inline void foo() override {cout << "Derived::foo()" << endl;}
};int main() 
{Base* ptr = new Derived();ptr->foo();delete ptr;return 0;
}

class Base {
public:virtual void foo() {std::cout << "Base::foo()" << std::endl;}static virtual void bar()  // 尝试将静态成员函数声明为虚函数{std::cout << "Base::bar()" << std::endl;}
};int main() {Base::bar(); // 直接通过类名调用静态成员函数return 0;
}

class TimeKeeper
{
public:TimeKeeper() {}~TimeKeeper() {} //非virtual的
};
//都继承与TimeKeeper
class AtomicClock :public TimeKeeper{};
class WaterClock :public TimeKeeper {};
class WristWatch :public TimeKeeper {};

TimeKeeper* getTimeKeeper()
{//返回一个指针，指向一个TimeKeeper派生类的动态分配对象
}

TimeKeeper* ptk = getTimeKeeper();delete ptk;

class TimeKeeper
{
public:TimeKeeper() {}virtual ~TimeKeeper() {}
};