C语言模式实现C++继承和多态的实例代码

为了实现C++的继承和多态概念，可以在C语言中定义结构体来模拟类的概念，通过指针来实现函数的虚函数（相当于C++中的纯虚函数）。下面我将讲解具体的步骤和示例代码。

1. 声明父类结构体

先用结构体来定义一个父类，并声明父类的成员变量和方法。注意在结构体内部也要使用指针来模拟虚函数表的概念。

typedef struct Parent {
    int m_val;
    void (*print)(struct Parent* this);
} Parent;

2. 声明子类结构体

类似地，可以定义一个子类结构体，继承父类的结构体。子类可以添加自己的成员变量和函数，也可以重新实现父类的函数来实现多态。

typedef struct Child {
    Parent parent;
    char* m_name;
    void (*print)(struct Child* this);
} Child;

3. 定义虚函数

为了定义虚函数，父类的结构体和子类的结构体都必须声明一个指向函数的指针。然后在函数定义时使用这个指针实现多态性。

以父类的 print 函数为例：

void Parent_print(Parent* this) {
    printf("Parent m_val = %d\n", this->m_val);
}

4. 定义子类函数

子类的函数要重写父类的函数，也可以实现自己的函数。为了实现多态，重写函数时要用父类的函数指针来调用父类的函数。

以子类的 print 函数为例：

void Child_print(Child* this) {
    printf("Child m_name = %s\n", this->m_name);
    Parent* parent = (Parent*) this;
    parent->print(parent);
}

5. 使用虚函数实现多态

要实现多态性，需要在调用虚函数时使用子类的指针，但是实际上调用的是父类的函数。然后在父类函数内部调用子类的虚函数时，又会调用子类自己的函数实现多态。

以调用 print 函数为例：

void print(Parent* parent) {
    parent->print(parent);
}

int main() {
    Parent parent = {10, Parent_print};
    Child child = {{20, Child_print}, "Alice"};
    print((Parent*) &parent);
    print((Parent*) &child);
    return 0;
}

在程序运行时，print 函数会依次输出 "Parent m_val = 10" 和 "Child m_name = Alice"，实现了多态性。

示例1：实现一个画图库

接下来，我将展示一个具体的示例来实现一个小型的画图库。该库有一个基类 Shape，具有一个纯虚函数 Draw，然后定义两个子类 Circle 和 Rectangle 分别重写 Draw 函数。最终，在 main 函数中调用 Draw 函数，可以分别绘制圆和矩形。

#include <stdio.h>

typedef struct Shape {
    void (*Draw)(struct Shape* this);
} Shape;

typedef struct Circle {
    Shape shape;
    int m_x;
    int m_y;
    int m_r;
} Circle;

typedef struct Rectangle {
    Shape shape;
    int m_x;
    int m_y;
    int m_w;
    int m_h;
} Rectangle;

void Shape_Draw(Shape* this) {
}

void Circle_Draw(Circle* this) {
    printf("Circle at (%d, %d) with r = %d\n", this->m_x, this->m_y, this->m_r);
}

void Rectangle_Draw(Rectangle* this) {
    printf("Rectangle at (%d, %d) with w = %d, h = %d\n", this->m_x, this->m_y, this->m_w, this->m_h);
}

void Draw(Shape* shape) {
    (shape->Draw)(shape);
}

int main() {
    Circle circle = {{Circle_Draw}, 10, 20, 30};
    Rectangle rectangle = {{Rectangle_Draw}, 50, 60, 70, 80};
    Draw((Shape*) &circle);
    Draw((Shape*) &rectangle);
    return 0;
}

示例2：实现一个交通工具类

在第二个示例中，我们将实现一个简单的交通工具类。类似于汽车、飞机等交通工具，通过定义一个 Vehicle 类，并定义出基本属性和行为（如类型、颜色、速度等），再以其派生出两个子类 Car 和 Airplane，通过继承和多态性来实现各个实例之间的差异。

#include <stdio.h>

typedef struct Vehicle {
    char* type;
    char* color;
    float speed;
    void (*Sound)(struct Vehicle* this);
} Vehicle;

typedef struct Car {
    Vehicle vehicle;
    int wheels;
} Car;

typedef struct Airplane {
    Vehicle vehicle;
    int wings;
} Airplane;

void Vehicle_Sound(Vehicle* this) {
}

void Car_Sound(Car* this) {
    printf("Car engine sound\n");
}

void Airplane_Sound(Airplane* this) {
    printf("Airplane engine sound\n");
}

void Sound(Vehicle* vehicle) {
    (vehicle->Sound)(vehicle);
}

int main() {
    Car car = {{ "Automobile", "Red", 100, Car_Sound }, 4};
    Airplane airplane = {{ "Aircraft", "White", 900, Airplane_Sound }, 2};
    Sound((Vehicle*) &car);
    Sound((Vehicle*) &airplane);
    return 0;
}

在程序运行时，Sound 函数会依次输出 "Car engine sound" 和 "Airplane engine sound"，实现了多态性。