C去实现C++面向对象性质

C++中面向对象的性质有，封装、继承和多态。

封装

C中的struct结构体，属性（成员变量）和方法（成员函数）

成员变量：直接在结构体内部定义即可

成员函数：C中的struct结构体内部不可以定义函数

所以我们采用全局函数 + 结构体指针参数 实现类似于成员函数的功能

继承

使用类似组合的方式【通过嵌套结构体】

多态

多态的调用，离不开虚表

在C中我们可以用函数指针来模拟虚表，在不同子类的构造函数中，对基类的函数指针进行赋值。从而实现多态的调用。

#include <stdio.h>

// =========================
// 模拟 C++ 中的封装特性
// =========================
typedef struct Person
{
    char* name;
    int age;

    // 虚函数指针：用于实现多态
    void (*speak)(struct Person* base);
} Person;

// 构造函数（初始化函数）
// 实现封装：封装对象初始化逻辑
void InitPerson(Person* base, char* name, int age)
{
    base->name = name;
    base->age = age;
}

// =========================
// 模拟 C++ 中的继承和多态特性（Student 继承 Person）
// =========================
typedef struct Student
{
    Person base;  // 模拟继承
    int grade;
} Student;

// 子类重写父类的虚函数，实现多态
void studentSpeak(Person* base)
{
    printf("student can speak");
}

// 子类构造函数，初始化父类和子类成员
void InitStudent(Student* stu, char* name, int age, int grade)
{
    InitPerson(&stu->base, name, age);       // 初始化父类成员
    stu->grade = grade;
    stu->base.speak = studentSpeak;          // 多态：赋予子类版本的 speak
}

// 子类的专属成员函数
void study(Student* stu)
{
    printf("member student can study");
}

// =========================
// Teacher 类，继承 Person
// =========================
typedef struct Teacher
{
    Person base;  // 模拟继承
    int teachyear;
} Teacher;

// Teacher 实现自己的 speak 版本，实现多态
void teacherSpeak(Person* base)
{
    printf("teacher can speak");
}

// Teacher 构造函数
void InitTeacher(Teacher* teacher, char* name, int age, int teachyear)
{
    InitPerson(&teacher->base, name, age);        // 初始化父类成员
    teacher->teachyear = teachyear;
    teacher->base.speak = teacherSpeak;           // 多态：赋予子类版本的 speak
}

// Teacher 的成员函数
void teach(Teacher* teacher)
{
    printf("member teacher can teach");
}

// =========================
// 主函数：模拟 C++ 面向对象编程调用方式
// =========================
int main()
{
    // 创建并初始化一个 Student 对象
    Student stu;
    InitStudent(&stu, "Tom", 18, 100);

    // 创建并初始化一个 Teacher 对象
    Teacher tch;
    InitTeacher(&tch, "Alice", 35, 10);

    // 模拟多态：通过父类指针调用子类的 speak 函数
    Person* p1 = (Person*)&stu;
    Person* p2 = (Person*)&tch;

    // 多态调用：输出子类自己的 speak 实现
    p1->speak(p1);  // 输出：student can speak
    printf("\n");
    p2->speak(p2);  // 输出：teacher can speak
    printf("\n");

    // 调用各自的子类专属成员函数（非多态）
    study(&stu);    // 输出：member student can study
    printf("\n");
    teach(&tch);    // 输出：member teacher can teach
    printf("\n");

    return 0;
}