纯C语言实现面向对象：封装、继承与多态原理及代码示例

/* 基类 */
struct parent_class {
    int a;
};

/* 子类，parent_class 必须位于首位 */
struct child_class {
    struct parent_class parent;
    int b;
};

void func() {
    struct child_class obj;
    struct parent_class *parent_ptr = (struct parent_class *)&obj;
    
    // 通过父类指针访问共同属性，底层内存布局一致
    parent_ptr->a = 10;
}

// 基类包含虚函数指针
struct Shape {
    int edges;
    int (*getArea)(void* self);
};

// 子类初始化时设置虚函数
void Triangle_init(struct Triangle* self) {
    self->base.getArea = triangle_getArea_impl;
}

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define Class struct
#define Interface struct

// 抽象形状类结构体
Class Shape {
    int edges;
    int (*getEdges)(void* self);
    int (*getArea)(void* self);
};
typedef Class Shape shape;

// 构造函数
shape* Shape_new(int edges) {
    shape *obj = (shape*) malloc(sizeof(shape));
    assert(obj != NULL);
    obj->edges = edges;
    obj->getEdges = shape_getEdges_default;
    obj->getArea = shape_getArea_default;
    return obj;
}

// 默认实现方法
int shape_getEdges_default(void* self) {
    shape* s = (shape*)self;
    return s ? s->edges : 0;
}

int shape_getArea_default(void* self) {
    return -1; // 返回-1表示未实现，用于抽象类
}

// 析构函数
void Shape_delete(shape *obj) {
    if(obj) {
        free(obj);
    }
}

// 三角形类结构体
Class Triangle {
    shape base;       // 继承自 Shape
    int bottom;
    int height;
    int (*getEdges)(void* self);
    int (*getArea)(void* self);
};
typedef Class Triangle triangle;

// 构造函数
triangle* Triangle_new(int bottom, int height) {
    triangle* obj = (triangle*) malloc(sizeof(triangle));
    assert(obj != NULL);
    
    // 初始化父类部分
    obj->base.edges = 3;
    obj->base.getEdges = triangle_getEdges;
    obj->base.getArea = triangle_getArea;
    
    // 初始化子类特有数据
    obj->bottom = bottom;
    obj->height = height;
    obj->getEdges = triangle_getEdges;
    obj->getArea = triangle_getArea;
    
    return obj;
}

// 三角形特有方法
int triangle_getEdges(void* self) {
    triangle* t = (triangle*)self;
    return t ? t->base.edges : 0;
}

int triangle_getArea(void* self) {
    triangle* t = (triangle*)self;
    if(t == NULL) return 0;
    return (t->bottom * t->height) / 2;
}

// 析构函数
void Triangle_delete(triangle *obj) {
    if(obj) {
        // 先释放父类资源（如果需要额外清理）
        Shape_delete((shape*)obj); // 注意：这里简单起见直接free，实际复杂继承需小心
        free(obj);
    }
}

// 矩形类结构体
Class Rectangle {
    shape base;
    int bottom;
    int height;
    int (*getEdges)(void* self);
    int (*getArea)(void* self);
};
typedef Class Rectangle rectangle;

// 构造函数
rectangle* Rectangle_new(int bottom, int height) {
    rectangle* obj = (rectangle*) malloc(sizeof(rectangle));
    assert(obj != NULL);
    
    obj->base.edges = 4;
    obj->base.getEdges = rectangle_getEdges;
    obj->base.getArea = rectangle_getArea;
    
    obj->bottom = bottom;
    obj->height = height;
    obj->getEdges = rectangle_getEdges;
    obj->getArea = rectangle_getArea;
    
    return obj;
}

int rectangle_getEdges(void* self) {
    rectangle* r = (rectangle*)self;
    return r ? r->base.edges : 0;
}

int rectangle_getArea(void* self) {
    rectangle* r = (rectangle*)self;
    if(r == NULL) return 0;
    return r->bottom * r->height;
}

void Rectangle_delete(rectangle *obj) {
    if(obj) {
        free(obj);
    }
}

void main(){
    // 1. 测试抽象基类
    shape* shapeObj = Shape_new(0);
    printf("Shape Edges: %d, Area: %d\n", 
           shapeObj->getEdges(shapeObj), 
           shapeObj->getArea(shapeObj));
    Shape_delete(shapeObj);

    // 2. 测试三角形
    triangle* triangleObj = Triangle_new(4, 5);
    printf("Triangle Edges: %d, Area: %d\n", 
           triangleObj->base.getEdges(triangleObj), 
           triangleObj->base.getArea(triangleObj));
    Triangle_delete(triangleObj);

    // 3. 测试矩形
    rectangle* rectangleObj = Rectangle_new(4, 5);
    printf("Rectangle Edges: %d, Area: %d\n", 
           rectangleObj->base.getEdges(rectangleObj), 
           rectangleObj->base.getArea(rectangleObj));
    Rectangle_delete(rectangleObj);
}