C语言实现多态（这些比较好）

综述
多态性是面向对象程序设计的一个重要特征，利用多态性能够设计和实现一个易于扩展的系统。

顾名思义，多态的意思是多种形态，在C++程序设计中，多态指的是：具备不一样功能的函数能够用同一个函数名，这样能够用一个函数名调用不一样内容的函数。

C++的多态分两种：静态多态性和动态多态性。

1. C++中的函数重载和运算符重载实现的多态性就属于静态多态，在程序编译时系统就能决定调用的是哪一个函数，所以静态多态性又称为编译时多态性。静态多态性是经过函数重载实现的（运算符重载实质上也是函数重载）。

2.动态多态实在程序运行过程当中才动态肯定操做指针指向的对象。它又被称为运行时多态。动态多态是经过虚函数实现的。

C语言虽然不是面向对象的语言，可是C语言一样能够实现多态性，在Linux 内核中就大量存在利用C语言实现多态性的代码。

C语言实现编译时多态性
C语言能够经过宏实现编译时多态，下面是一个例子：
#define ADD(A, B) (A) + (B);
int main(){
    int a =1;
    int b =2;
    cout<<ADD(a,b);//输出3
    string c = "asd";
    string d = "fff";
    cout<<ADD(c,d);//输出 asdfff
    return 0;
}

对于不一样的类型的A和B，带参数的宏 ADD 会根据传入的是 int类型或是string 类型而采起不一样的 +的策略。
C语言实现动态多态性
C语言能够用函数指针实现动态多态，下面是例子：
#include <stdio.h>
#include <stdlib.h>
 
//虚函数表结构
struct base_vtbl
{
    void(*dance)(void *);
    void(*jump)(void *);
};
 
//基类
struct base
{
    /*virtual table*/
    struct base_vtbl *vptr;
};
 
void base_dance(void *this)
{
    printf("base dance\n");
}
 
void base_jump(void *this)
{
    printf("base jump\n");
}
 
/* global vtable for base */
struct base_vtbl base_table =
{
        base_dance,
        base_jump
};
 
//基类的构造函数
struct base * new_base()
{
    struct base *temp = (struct base *)malloc(sizeof(struct base));
    temp->vptr = &base_table;
    return temp;
}
 
 
//派生类
struct derived1
{
    struct base super;
    /*derived members */
    int high;
};
 
void derived1_dance(void * this)
{
    /*implementation of derived1's dance function */
    printf("derived1 dance\n");
}
 
void derived1_jump(void * this)
{
    /*implementation of derived1's jump function */
    struct derived1* temp = (struct derived1 *)this;
    printf("derived1 jump:%d\n", temp->high);
}
 
/*global vtable for derived1 */
struct base_vtbl derived1_table =
{
    (void(*)(void *))&derived1_dance,
    (void(*)(void *))&derived1_jump
};
 
//派生类的构造函数
struct derived1 * new_derived1(int h)
{
    struct derived1 * temp= (struct derived1 *)malloc(sizeof(struct derived1));
    temp->super.vptr = &derived1_table;
    temp->high = h;
    return temp;
}
 
 
 
int main(void)
{
 
    struct base * bas = new_base();
    //这里调用的是基类的成员函数
    bas->vptr->dance((void *)bas);
    bas->vptr->jump((void *)bas);
 
 
    struct derived1 * child = new_derived1(100);
    //基类指针指向派生类
    bas  = (struct base *)child;
 
    //这里调用的实际上是派生类的成员函数
    bas->vptr->dance((void *)bas);
    bas->vptr->jump((void *)bas);
    return 0;
}

上面代码不只实现了多态的性质，其实也在模拟C++中的类的继承。主函数中基类指针 bas 一开始指向的是基类对象，所以调用 dance 和jump是基类的dance jump 。下面把bas 指向派生类的对象，再调用dance 和jump 的时候就不是基类的dance 和jump了，而转化成了派生类的dance 和jump.
--------------------- 
做者：feiqiangs 
来源：CSDN 
原文：https://blog.csdn.net/dumpling5232/article/details/52632060 
版权声明：本文为博主原创文章，转载请附上博文连接！