C++继承与多态

---

前言

本文介绍了C++继承与多态，基于施磊老师的C++课程。

---

一、继承的基本意义

父类和子类可以有同名的成员变量，用作用域区分。

继承方式以及成员变量的访问权限：

总结：
1、外部只能访问对象public的成员，protected和private的成员无法直接访问
2、在继承结构中，派生类从基类可以继承过来private的成员，但是派生类却无法直接访问
3、protected和private的区别？在基类中定义的成员，想被派生类访问，但不想被外部访问，那么在基类中，把相关成员定义为protected保护的；如果派生类和外部都不打算访问，那么在基类中，就把相关成员定义为private私有的。

二、重载、隐藏、覆盖

1、重载
一组函数重载，必须处于同一个作用域中；并且函数名字相同，参数列表不同

2、隐藏
在继承结构中，派生类的同名成员，把基类中的同名成员给隐藏调用了

对于基类和派生类之间的转换，一般只支持从派生类转化为基类（即从下到上的转换）

三、虚函数、静态绑定和动态绑定

1、一个类里面定义了虚函数，那么编译阶段，编译器给这个类类型产生一个唯一的vftable虚函数表，虚函数表中主要存储的内容就是RTTI指针和虚函数的地址。当程序运行时，每一张虚函数表都会加载到内存的.rodata区。

2、一个类里面定义了虚函数，那么这个类定义的对象，在其运行时，内存中的开始部分，会多存储一个vfptr虚函数指针，指向对应类类型的虚函数表。一个类定义的n个对象，他们指向的都是同一张虚函数表。

3、一个类里面虚函数的个数，不影响对象内存的大小，影响的是虚函数表的大小。

4、如果派生类中的方法，和基类继承来的某个方法，返回值、函数名、参数列表都相同，而且基类的方法是virtual虚函数，那么派生类的这个方法，自动处理成虚函数

对于派生类中和基类中相同的函数，会在派生类的虚函数表中将对应表项覆盖：

四、虚析构函数

Q1、哪些函数不能实现成虚函数？
虚函数依赖：

1. 虚函数能产生地址，存储在虚函数表中
2. 对象必须存在（即通过虚函数指针找到虚函数表，再通过虚函数表找到虚函数地址）

构造函数不能成为虚函数，因为在调用构造函数时，对象尚未存在，也就无法通过虚函数指针查找虚函数表。
其次，在构造函数中调用虚函数也不会发生动态绑定。

static静态成员方法也不能成为虚函数，static成员方法的调用不依赖对象

Q2、为什么应当将析构函数实现成虚函数？

当我们使用基类指针指向堆上开辟的派生类类型的对象时，如果对基类指针delete，就会导致只调用基类的析构函数，不调用派生类的析构函数，发生问题：

#include <iostream>

using namespace std;

class Base
{
public:
    Base(int data) : ma(data) { cout << "Base()" << endl; }
    ~Base() { cout << "~Base()" << endl; }
private:
    int ma;
};

class Derive : public Base
{
public:
    Derive(int data) : Base(data), mb(data) { cout << "Derive()" << endl; }
    ~Derive() { cout << "~Derive()" << endl; }
private:
    int mb;
};

int main()
{

    Base* pb = new Derive(10);
    delete pb;

    /*
    输出：
        Base()
        Derive()
        ~Base()
    */
    return 0;
}

将基类的析构函数实现为虚函数即可：

virtual ~Base() { cout << "~Base()" << endl; }

五、再谈动态绑定

Q：是不是虚函数的调用就一定是动态绑定？

不是，在类的构造函数中，调用虚函数，也是静态绑定。

此外，直接用对象本身调用虚函数也不会发生动态绑定。

要发生动态绑定，需要使用指针或者引用。

六、理解多态

Q：如何解释多态？
静态（编译时期）多态：
函数重载、模板（函数模板、类模板）

动态（运行时期）多态：
在继承结构中，基类指针（引用）指向派生类对象，通过该指针（引用）调用同名覆盖方法（虚函数），基类指针指向哪个派生类的对象，就会调用哪个派生类对象的同名覆盖方法，称为多态。

笔试题：
待补充

七、理解抽象类

拥有纯虚函数的类叫做抽象类，抽象类不能在实例化对象，但是可以定义指针或者引用变量。

//纯虚函数
virtual void func() = 0;

八、理解虚基类和虚继承

virtual关键字：
1、修饰成员方法表示虚函数
2、修饰继承方式表示虚继承。被虚继承的类称作虚基类。
虚继承中的派生类不仅会存储自己的虚函数表vftable，还会存储一个用于 指向 指示基类数据的vbtable 指针vbptr。

基类指针指向派生类对象，永远指向的是派生类中基类部分数据的起始地址：

九、菱形继承

虚继承可以用于解决菱形继承的问题，参考这篇文章：菱形继承

十、C++的四种类型转换

1、const_cast: 去除常量属性的类型转换
a.需要类型匹配，不像C能够进行强制转换。
b.只能用于指针或者引用

const_cast是语言级别的，看不到源码实现，从汇编代码上来看和C的强制转换是一样的。

const int a = 10;
int *p0 = const_cast<int*>(&a);         // 编译正确
double *p1 = (double*)&a;               // 编译正确
double *p2 = const_cast<double*>(&a);   // 编译错误
int p3 = const_cast<int>(a);            // 编译错误

2、static_cast：提供编译器认为安全的类型转换

没有任何联系的类型之间进行转换会被否定：

int p = 10;
// 以下三行均编译正确
int b0 = static_cast<int>(p);
char b1 = static_cast<char>(p);
double b2 = static_cast<double>(p);

// 以下两行均编译错误
int *p1 = nullptr;
short *c1 = static_cast<short*>(p1);
double *c2 = static_cast<double*>(p1);

对于基类类型和派生类类型之间的static_cast转换，一般都是可以的，因为二者之间有关联

3、reinterpret_cast：类似于C风格的强制类型转换

4、dynamic_cast：主要用于继承结构中，可以支持RTTI类型识别的上下转换

#include<iostream>

using namespace std;

class Base {
public:
    virtual void func() { cout << "Base::func()" << endl; }
};

class Derive1 : public Base {
public:
    void func() { cout << "Derive1::func()" << endl; }
};

class Derive2 : public Base {
public:
    void func() { cout << "Derive2::func()" << endl; }
    void derive2Func() { cout << "Derive2::derive2Func()" << endl; }
};

void showFunc(Base *p) {
    // dynamic_cast会检查p指针是否指向的是一个Derive2类型的对象
    // 返回Derive2对象的地址，如果不是Derive2类型，返回nullptr
    Derive2 *pd2 = dynamic_cast<Derive2*>(p);
    if (pd2 != nullptr) {
        pd2->func();
    } else {
        p->func();
    }
}

int main()
{
    Derive1 d1;
    Derive2 d2;
    showFunc(&d1);
    showFunc(&d2);
    return 0;
}