C++技能进阶指南——多态语法剖析

前言：多态是面向对象的三大特性之一。顾名思义，多态就是多种状态。那么是什么的多种状态呢？这里的可能有很多。比如我们去买火车票，有普通票，学生票；又比如我们去旅游，有儿童票，有成人票等等。这些都是多态的例子。具体转化为我们的编程思想就是：让不同类型的对象去完成相同的事，这就是多态。

本篇内容主要讲述多态，多为语法方面的知识点。适合已经学完继承的友友们观看。

一、多态的相关概念

1.1虚函数

1.2虚函数的重写

1.3虚函数重写的两个例外

1.4override 和 final 的使用

二、重载、重写、隐藏（重定义）的区别

三、如何构成多态

四、抽象类

五、普通继承和接口继承

六、静态绑定和动态绑定

具体什么是多态在前言中已经提到，正文部分不做赘述。

一、多态的相关概念

1.1虚函数

被virtual关键字修饰的成员函数叫做虚函数。例如：

//A位基类
class A 
{
public:virtual void func()    //定义一个虚函数{cout << "Afunc()" << endl;}
};

需要注意的是，对于构造函数和析构函数来说。析构函数可以是虚函数，但是构造函数不可以是虚函数。

具体原因如下：（建议看完整篇文章和总结虚函数表机制——c++多态底层原理-CSDN博客之后再来看下面这段解释）：

首先：通过之前的学习，我们知道了，虚函数的地址是存在虚函数表里面的。想要调用对应的虚函数，我们需要先去虚函数表中寻找对应虚函数的地址。但是虚函数表是在构造函数的初始化列表初始化的。如果构造函数是虚函数，那么调用构造函数的时候就找不到。所以构造函数没办法是虚函数。

1.2虚函数的重写

虚函数的重写就是：在派生类当中，有一个和基类中某一个虚函数函数头的虚函数（函数头就是：函数的返回值，函数名，函数的参数列表）。这个时候就会构成虚函数的重写, 即 子类重写了基类的虚函数。

//A位基类
class A 
{
public:virtual void func() {cout << "Afunc()" << endl;}
};//B类继承A类
class B : public A
{
public://重写A类的func函数virtual void func()  //注意， 这里的virtual可以不写， 因为编译器默认这里是加了virtual的{cout << "Bfunc()" << endl;}
};

需要注意的是，上图中派生类的func可以不加virtual，因为基类的func是虚函数，编译器会默认派生类中和他函数头相同的函数也是虚函数。

1.3虚函数重写的两个例外

协变:派生类在重写基类的虚函数的时候，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用的时候，成为协变。


//A位基类
class A
{
public:virtual A* func(){cout << "Afunc()" << endl;}
};//B类继承A类
class B : public A
{
public://重写A类的func函数virtual B* func(){cout << "Bfunc()" << endl;}
};//C类继承A类
class C : public A
{virtual C* func(){cout << "Cfunc" << endl;}
};

析构函数的重写: 基类析构函数如果加了virtual，那么说明基类的析构函数为虚函数。这个时候如果派生类的析构函数也就变成了虚函数。那么成不成为虚函数对于析构函数来说有什么不同呢？

首先我们需要知道的是，在一个普通的类之中，编译器其实将析构函数统一处理成为了destructor。

然后，对于一个派生类来说，如果它的析构函数不是虚函数。当我们使用父类的指针构成多态时，只会析构派生类的一部分:

//A位基类
class A
{
public:virtual A* func(){cout << "Afunc()" << endl;}//其他动态内存分配的空间//int* ...//double* ...
};//B类继承A类
class B : public A
{
public://重写A类的func函数virtual B* func(){cout << "Bfunc()" << endl;}//其他动态内存分配的空间//int* ...//double* ...
};void test_func(A* p)
{p->func();
}int main() 
{C c;A* p = nullptr;p = &c;delete p;return 0;
}

如上图，假如delete p，那么就只能释放属于C类自己的那一部分。那么属于A类的那一部分将得不到释放。

但是，如果我们对A类的析构函数使用虚函数。那么派生类的析构函数也变成了虚函数，这个时候如果再形成多态。delete p就能将A类和C类都释放掉。


//A位基类
class A
{
public:virtual A* func(){cout << "Afunc()" << endl;}virtual ~A() {}
};//B类继承A类
class B : public A
{
public://重写A类的func函数virtual B* func(){cout << "Bfunc()" << endl;}virtual ~B(){}
};

1.4override 和 final 的使用

先谈override， override是用来检验某个虚函数是否构成了重写。如果没有构成重写，那么编译器就会报错。

如下为构成重写:

//A位基类
class A
{
public:virtual void func(){cout << "Afunc()" << endl;}};
//B类继承A类
class B : public A
{
public://重写A类的func函数virtual void func() override{cout << "Bfunc()" << endl;}};

如下为没有构成重写：


//A位基类
class A
{
public:void func(){cout << "Afunc()" << endl;}
};
//B类继承A类
class B : public A
{
public://重写A类的func函数virtual void func() override{cout << "Bfunc()" << endl;}};

二、重载、重写、隐藏（重定义）的区别

重载： 函数处于相同作用域内，并且函数的函数名相同，参数不同。
重写： 函数分别处于基类和派生类中，并且都是虚函数，并且有相同的函数头
隐藏： 继承体系中函数分别处在基类和派生类的作用与之中，不是虚函数，并且都具有相同的函数头

三、如何构成多态

要形成多态有两个条件：

一、虚函数的重写。
二、父类的指针指向子类,或者父类的引用引用子类对象。

如下为一个多态的实例：

//A位基类
class A 
{
public:virtual void func() {cout << "Afunc()" << endl;}
};//B类继承A类
class B : public A
{
public:virtual void func() {cout << "Bfunc()" << endl;}
};//C类继承A类
class C : public A
{virtual void func() {cout << "Cfunc" << endl;}
};int main() 
{C c;B b;A* p = nullptr;p = &c;p->func();p = &b;p->func();return 0;
}
在这串代码中， B类和C类都是A类的派生类。他们都有对A类中的虚函数func进行重写，满足条件一。

然后基类的指针p先是指向了C类的对象。又指向了B类的对象。构成了父类的指针指向子类，满足条件二。

所以，这就是一个多态。

其实，多态的应用场景多为这样：


//A位基类
class A 
{
public:virtual void func() {cout << "Afunc()" << endl;}
};//B类继承A类
class B : public A
{
public:virtual void func() {cout << "Bfunc()" << endl;}
};//C类继承A类
class C : public A
{virtual void func() {cout << "Cfunc" << endl;}
};void test_func(A* p) 
{p->func();
}int main() 
{C c;B b;test_func(&b);test_func(&c);return 0;
}

这样，通过传送不同类型的对象给test_func函数，就能构成多态。

四、抽象类

如果一个虚函数后面加上 =0，那么这个虚函数就是纯虚函数，并且包含这个纯虚函数的类叫做抽象类。

抽象类不能实例化对象。


//A位基类
class A
{
public:virtual void func() = 0;
};int main() 
{A a;return 0;
}

但是A的派生类如果重写了纯虚函数，那么就可以这个派生类就可以实例化处对象。

但是如果A的派生类没有重写纯虚函数，那么这个派生类同样不能实例化处对象。


//A位基类
class A
{
public:virtual void func() = 0;
};//B类继承A类
class B : public A
{
public://重写A类的func函数
};int main() 
{B b;return 0;
}

五、普通继承和接口继承

普通继承：在继承体系中，派生类继承了基类的函数，能够直接使用的是普通继承，这类继承继承的是基类函数的实现。

接口继承：如果继承了基类的虚函数，并且重写实现了多态。那么就是一种接口继承，多态的体系是一种接口的继承，具体的函数实现是由派生类自己实现的。

六、静态绑定和动态绑定

静态绑定：静态绑定又被成为前期绑定, 当程序在编译的时候确定的要调用的函数，确定了程序要执行的行为，这个过程成为静态多态。比如我们使用的函数重载就是静态的多态。

动态绑定：动态绑定又被成为后期绑定，当程序在编译之后也就是运行期间根据不同的对象调用不同的函数。这个过程叫做动态多态，也就是多态。

------------------------------------------------------

ps：本篇内容没有讲解多态的原理，因为多态的原理其实就是虚函数表。而虚函数表的详细讲解博主之前已经写过一篇：总结虚函数表机制——c++多态底层原理-CSDN博客。

在这篇文章中，博主用自己的理解讲解的虚函数表的机制与实现。写的不甚严谨，但是里面的结论却是博主通过调试一步一步验证的来的。感兴趣的友友们可以看一下。

后续补带有虚函数的类的内存大小的计算（暂时有点模糊，先不写，而且最近考试比较多。可能要等暑假才能补上这一板块）。