C语言实现多态机制

今天，看到一篇面经，问的是如何通过C语言实现多态。特意记录一下答案。

题外话

面向对象的三大特征

封装：
对于封装来说就是数据与具体操作实现的代码都放在某个对象的内部，使这些代码的具体细节不被外界发现，只留下一些接口供外部来使用，而不能一任何的形式来对象内部的实现。使用封装能够隐藏具体的实现的细节，使代码更加易于维护并且保证了系统的安全性。
继承：
继承机制是面向对象程序设计使代码进行复用的最重要的手段，他允许程序员在保证类原有类特性的基础上进行扩展来增加功能。这样新产生的类就被称为派生类，继承就可以表现面向对象机制的的层次结构。
多态：
多态简单点说就是“一个接口，多种实现”，就是同一种事物表现出的多种形态。多态在面向对象语言中是指：接口多种的不同实现方式。也就是复用相同接口，实现不同操作。

总的来说：封装可以隐藏实现细节包括包含私有成员，使得代码模块增加安全指数；继承可以扩展已存在的模块，为了增加代码的复用性；多态则是为了保证类在继承和派生的时候，类的实例被正确调用，实现了接口的重用

静态多态&动态多态

C++多态支持两种多态性，编译时多态和运行时多态。编译时多态是通过重载函数来实现的，运行时多态是通过虚函数来实现的。

静态多态：编译器在编译期间完成，编译器根据函数实参的类型（可能会隐式类型转换），可推断出要调用哪个函数，如果有对应的函数就调用相应的函数，否则就报一个编译错误。

动态多态：在函数执行期间（非编译期）判断所引用对象的实际类型，根据实际类型的调用相应的方法。使用virtual关键字修饰类的成员函数，指明该函数为虚函数，派生类需要重新实现，编译器将实现动态绑定。

动态多态实现的条件：

1. 使用场景：父类的指针或者引用指向父类或者子类的对象（由赋值兼容规则决定）；
2. 实现多态的两个条件：虚函数的重写；父类的指针或者引用调用重写的虚函数。
3. 若父类中的成员函数加上virtual关键字，则子类中重写的该函数默认virtual，可以不指定，但是一般加上；
   重写：子类重写父类的虚函数，要求函数名称，函数参数，返回值完全一样（协变除外）；

C++中的多态

我们知道的是在C++中会维护一张虚函数表，根据赋值兼容规则，我们知道父类的指针或者引用是可以指向子类对象的。如果一个父类的指针或者引用调用父类的虚函数则该父类的指针会在自己的虚函数表中查找自己的函数地址，如果该父类对象的指针或者引用指向的是子类的对象，而且该子类已经重写了父类的虚函数，则该指针会调用子类的已经重写的虚函数。

//c++中的多态
#include <iostream>
using namespace std;
class A
{
public:
    virtual void fun()//虚函数实现
    {
        cout << "Base A::fun() " << endl;
    }
};

class B:public A
{
public:
    virtual void fun()//虚函数实现,子类中virtual关键字可以没有
    {
        cout << "Derived B::fun() " << endl;
    }
};

void Test1()
{
    A a;//基类对象
    B b;//派生类对象

    A* pa = &a;//父类指针指向父类对象
    pa->fun();//调用父类的函数

    pa = &b; //父类指针指向子类对象，多态实现
    pa->fun();//调用派生类同名函数
}

输出：
Base A::fun()
Derived B::fun()

C语言实现多态

C语言中是没有class类这个概念的，但是有struct结构体，我们可以考虑使用struct来模拟；但是在C语言的结构体内部是没有成员函数的，如果实现这个父结构体和子结构体共有的函数呢？我们可以考虑使用函数指针来模拟。但是这样处理存在一个缺陷就是：父子各自的函数指针之间指向的不是类似C++中维护的虚函数表而是一块物理内存，如果模拟的函数过多的话就会不容易维护了。

//C实现动态，用到函数指针

typedef void(*FUN)();//重定义一个函数指针类型

//父类
struct Base 
{
    FUN _f;
};

//子类
struct Derived
{
    Base _b;//在子类中定义一个基类的对象即可实现对父类的继承
};


void FunB()
{
    printf("%s\n", "Base::fun()");
}
void FunD()
{
    printf("%s\n", "Derived::fun()");
}

void Test2()
{
    Base b;//父类对象
    Derived d;//子类对象

    b._f = FunB;//父类对象调用父类同名函数
    d._b._f = FunD;//子类调用子类的同名函数

    Base *pb = &b;//父类指针指向父类对象
    pb->_f();

    pb = (Base *)&d;//让父类指针指向子类的对象,由于类型不匹配所以要进行强转
    pb->_f();

}

结构体的强制类型转换

我们看到C语言通过强制类型转换完成多态的实现。

pb = (Base *)&d;//让父类指针指向子类的对象,由于类型不匹配所以要进行强转

因为Derived中只有一个Base类，在强制转换的过程中会把结构体d中的变量赋值给pb。如果说两个结构体中的前n个变量无法一一对应，则会出现段错误。

例如，定义Derived为

struct Derived
{
    int b;
    Base _b;//在子类中定义一个基类的对象即可实现对父类的继承
};

则输出

Base::fun()
Segmentation fault (core dumped)

但如果定义为

struct Derived
{
    Base _b;//在子类中定义一个基类的对象即可实现对父类的继承
    int b;
};

则正常输出。

参考：
C语言模式实现C++继承和多态.
纯C语言实现简单封装继承机制 .