序言：

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

（一）概念查考

（二）问答题

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

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

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

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

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

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

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

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

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

（一）概念查考

1. ( ) 是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，

而对方法的调用则可以关联于具体的对象

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

【答案】：D

2. 面向对象设计中的继承和组合，下面说法错误的是？（）

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

【答案】：C

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

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

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

3. 以下关于纯虚函数的说法 , 正确的是 ( )

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"。

（二）问答题

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

由于派生类重写基类方法，然后用基类引用指向派生类对象，调用方法时候会进行动态绑定，这就是多态。

多态分为静态多态和动态多态：

1. 静态多态：编译器在编译期间完成的，编译器会根据实参类型来推断该调用哪个函数，如果有对应的函数，就调用，没有则在编译时报错。

比如一个简单的加法函数：

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;//1
    cout<<Add('1','2');//2
    return 0;
}

【说明】

显然，第一条语句会调用函数1，而第二条语句会调用函数2，这绝不是因为函数的声明顺序，不信你可以将顺序调过来试试。

2.动态多态：其实要实现动态多态，需要几个条件——即动态绑定条件：

1. 虚函数。基类中必须有虚函数，在派生类中必须重写虚函数。
2. 通过基类类型的指针或引用来调用虚函数。

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

具体见我上一篇博客：C++ 的重载和重写，以及它们的区别

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

1. 重载： C++ 利用命名倾轧（ name mangling ）技术，来改名函数名，区分参数不同的同名函数。命名倾轧是在编译阶段完成的。编译时将参数类型加入以区分不同。

2. 重写： 在基类的函数前加上 virtual 关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。

虚函数需要注意的地方：

用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。
存在虚函数的类都有一个一维的虚函数表叫做虚表，类的对象有一个指向虚表开始的虚指针。
虚表是和类对应的，虚表指针是和对象对应的。
多态性是一个接口多种实现，是面向对象的核心，分为类的多态性和函数的多态性。
重写用虚函数来实现，结合动态绑定。
纯虚函数是虚函数再加上 = 0。
抽象类是指包括至少一个纯虚函数的类。

纯虚函数： virtual void fun()=0 。即抽象类必须在子类实现这个函数，即先有名称，没有内容，在

派生类实现内容。

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

可以，不过编译器就忽略 inline 属性，这个函数就不再是 inline，因为虚函数要放到虚表中去

在C++中，虚函数是用于实现运行时多态性的概念，而虚函数的调用是通过指针或引用来完成的。然而，内联函数（inline function）在编译时被展开，将函数的代码插入到调用处，以减少函数调用的开销。

由于内联函数的展开是在编译时完成的，而虚函数的调用是在运行时动态确定的，因此二者的机制存在冲突。虚函数的调用需要根据对象的实际类型确定调用的函数，而内联函数的展开则需要在编译时就确定函数体的具体代码。

当我们将虚函数声明为内联函数时，编译器会忽略内联关键字，而将其作为普通的成员函数对待。下面是一个示例代码，展示了虚函数声明为内联函数的情况：


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;
}

【说明】

在这个示例中，我们将基类 Base 中的虚函数 foo 声明为内联函数，并在派生类 Derived 中进行重写。然后，我们通过基类的指针调用虚函数 foo。
尽管我们在虚函数声明中加上了 inline 关键字，但编译器会忽略它，将其视为普通的成员函数。因此，在运行时仍然会根据实际类型进行动态绑定。

输出结果将是：

这表明虚函数 foo 被正确地重写，并且运行时根据实际对象类型进行了动态绑定。

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

静态成员函数不能被声明为虚函数。虚函数的多态性是通过在运行时动态绑定来实现的，而静态成员函数是与类本身相关联的，不依赖于特定的对象，因此无法进行动态绑定。

虚函数依赖于对象的虚表，通过对象的指针或引用来调用虚函数时，会根据对象的实际类型确定要调用的具体函数。而静态成员函数是与类关联，而不是与对象关联的，它可以通过类名直接调用，不依赖于特定的对象。

另外，静态成员函数没有 this 指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

综上所述，静态成员函数不能被声明为虚函数。

以下是一个示例代码，演示了将静态成员函数声明为虚函数将导致编译错误：

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;
}

上述代码中，我们尝试将静态成员函数bar()声明为虚函数。如果我们尝试编译这段代码，编译器将给出一个错误。

这个错误告诉我们无法将静态成员函数声明为虚函数。

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

1. 虚析构：

将可能会被继承的父类的析构函数设置为虚函数，可以保证当我们 new 一个子类，然后使用基类指针指向该子类对象，释放基类指针时可以释放掉子类的空间，防止内存泄漏。如果基类的析构函数不是虚函数，在特定情况下会导致派生类无法被析构。

1. 用派生类类型指针绑定派生类实例，析构的时候，不管基类析构函数是不是虚函数，都会正常析构
2. 用基类类型指针绑定派生类实例，析构的时候，如果基类析构函数不是虚函数，则只会析构基类，不会析构派生类对象，从而造成内存泄漏。为什么会出现这种现象呢，个人认为析构的时候如果没有虚函数的动态绑定功能，就只根据指针的类型来进行的，而不是根据指针绑定的对象来进行，所以只是调用了基类的析构函数；如果基类的析构函数是虚函数，则析构的时候就要根据指针绑定的对象来调用对应的析构函数了。

C++ 默认的析构函数不是虚函数是因为虚函数需要额外的虚函数表和虚表指针，占用额外的内存。

代码说明：

我们创建一个 TimeKeeper 基类和一些及其它的派生类作为不同的计时方法：

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

如果客户想要在程序中使用时间，不想操作时间如何计算等细节，这时候我们可以设计 factory （工

厂）函数，让函数返回指针指向一个计时对象。该函数返回一个基类指针，这个基类指针是指向于

派生类对象的

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

因为函数返回的对象存在于堆中，因此为了 在不使用时我们需要使用释放该对象（ delete ）

TimeKeeper* ptk = getTimeKeeper();

delete ptk;

此处基类的析构函数是非 virtual 的，因此 通过一个基类指针删除派生类对象是错误的

解决办法： 将基类的析构函数改为 virtual 就正确了

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

声明为 virtual 之后，通过 基类指针删除派生类对象就会释放整个对象（基类 + 派生类）

2. 不能虚构造：

1. 从存储空间角度：虚函数对应一个vtale,这个表的地址是存储在对象的内存空间的。如果将构造函数设置为虚函数，就需要到vtable 中调用，可是对象还没有实例化，没有内存空间分配，如何调用。（悖论）
2. 从实现上看：vbtl 在构造函数调用后才建立，因而构造函数不可能成为虚函数。

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

首先如果是普通对象，是一样快的；
如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

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

1. 虚函数表是一个存储虚函数地址的数组,以NULL结尾。虚表（vftable）在编译阶段生成，对象内存空间开辟以后，写入对象中的 vfptr，然后调用构造函数。即：虚表在构造函数之前写入
2. 除了在构造函数之前写入之外，我们还需要考虑到虚表的二次写入机制，通过此机制让每个对象的虚表指针都能准确的指向到自己类的虚表，为实现动多态提供支持。