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 
版權聲明：本文爲博主原創文章，轉載請附上博文連接！