C语言面向对象程序设计实验实验二类与对象的封装继承多态实践与常见问题解析

引言

C语言作为一门经典的结构化编程语言，本身并不直接支持面向对象（Object-Oriented, OO）的语法特性（如class、public、private、virtual等）。然而，通过巧妙地运用结构体（struct）、函数指针以及宏定义，我们完全可以在C语言中模拟出面向对象的核心思想：封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。

本实验旨在通过实践，帮助你理解如何在C语言底层实现这些高级抽象概念。这不仅有助于深入理解C语言的内存模型和指针操作，更能让你在阅读Linux内核等大量使用C语言编写的大型项目源码时游刃有余。

第一部分：封装（Encapsulation）—— 数据与操作的结合

1.1 理论基础

封装的核心在于将数据（属性）和操作数据的方法（行为）绑定在一起，并隐藏内部实现细节。在C语言中，我们通常使用struct来定义对象，将属性作为结构体的成员变量。为了实现“私有化”，我们通常采用不透明指针（Opaque Pointer）技术，即在头文件中只声明结构体指针，而将结构体的具体定义隐藏在源文件中。

1.2 实践代码：坐标点（Point）

我们将定义一个Point类，包含x和y坐标，并提供构造、析构、移动和打印的方法。

头文件 point.h

这里只暴露接口，不暴露Point结构体的具体细节，从而实现类似private的效果。

#ifndef POINT_H
#define POINT_H

// 前向声明，外部无法知道Point的具体结构，只能通过指针操作
typedef struct Point Point;

// 构造函数：创建对象
Point* Point_new(int x, int y);

// 析构函数：销毁对象，释放内存
void Point_delete(Point* self);

// 方法：修改坐标
void Point_move(Point* self, int dx, int dy);

// 方法：获取坐标
int Point_getX(const Point* self);
int Point_getY(const Point* self);

// 方法：打印信息
void Point_print(const Point* self);

#endif

源文件 point.c

在这里定义具体的结构体和实现逻辑。

#include <stdio.h>
#include <stdlib.h>
#include "point.h"

// 1. 定义结构体（相当于类的实现）
struct Point {
    int x; // 属性
    int y; // 属性
};

// 2. 构造函数实现
Point* Point_new(int x, int y) {
    Point* self = (Point*)malloc(sizeof(Point));
    if (self) {
        self->x = x;
        self->y = y;
    }
    return self;
}

// 3. 析构函数实现
void Point_delete(Point* self) {
    if (self) {
        free(self);
        self = NULL; // 防止野指针
    }
}

// 4. 方法实现
void Point_move(Point* self, int dx, int dy) {
    if (self) {
        self->x += dx;
        self->y += dy;
    }
}

int Point_getX(const Point* self) {
    return self ? self->x : 0;
}

int Point_getY(const Point* self) {
    return self ? self->y : 0;
}

void Point_print(const Point* self) {
    if (self) {
        printf("Point Object [%p]: (x=%d, y=%d)\n", (void*)self, self->x, self->y);
    }
}

测试文件 main.c

#include "point.h"

int main() {
    // 创建对象（实例化）
    Point* p1 = Point_new(10, 20);
    
    // 使用对象
    Point_print(p1); // 输出: Point Object [0x...]: (x=10, y=20)
    
    // 修改状态
    Point_move(p1, 5, -5);
    Point_print(p1); // 输出: Point Object [0x...]: (x=15, y=15)
    
    // 销毁对象
    Point_delete(p1);
    p1 = NULL; // 良好的习惯
    
    return 0;
}

1.3 常见问题解析：内存管理

问题：在C语言中没有垃圾回收机制，忘记调用Point_delete会导致内存泄漏。 解决：必须成对使用malloc和free。建议编写单元测试时，使用Valgrind等工具检测内存泄漏。

---

第二部分：继承（Inheritance）—— 代码复用与扩展

2.1 理论基础

继承允许一个结构体包含另一个结构体作为其第一个成员。由于C语言保证了结构体第一个成员的地址与结构体本身的地址相同，我们可以通过强制类型转换将子类对象视为父类对象来使用。这被称为结构体嵌套模拟继承。

2.2 实践代码：形状（Shape）与圆形（Circle）

我们定义一个基类Shape（包含颜色和面积计算接口），然后让Circle继承它。

头文件 shape.h

#ifndef SHAPE_H
#define SHAPE_H

// 基类 Shape
typedef struct Shape {
    char* color; // 属性：颜色
    // 虚函数表指针（模拟C++的vtable）可以放在这里，或者通过函数指针成员实现
    double (*getArea)(struct Shape* self); // 纯虚函数接口
    void (*draw)(struct Shape* self);
} Shape;

// 基类构造函数
Shape* Shape_new(char* color);
void Shape_delete(Shape* self);

// 子类 Circle
typedef struct Circle {
    Shape base; // 【关键】：必须作为第一个成员，实现继承
    double radius; // 子类特有属性
} Circle;

// 子类构造函数
Circle* Circle_new(char* color, double radius);

#endif

源文件 shape.c

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "shape.h"

// --- Shape 实现 ---
double Shape_getAreaImpl(Shape* self) {
    // 基类无法计算具体面积，通常定义为0或报错
    printf("Warning: Base class Shape cannot calculate area.\n");
    return 0.0;
}

void Shape_drawImpl(Shape* self) {
    printf("Drawing a generic shape with color: %s\n", self->color);
}

Shape* Shape_new(char* color) {
    Shape* self = (Shape*)malloc(sizeof(Shape));
    if (self) {
        self->color = color;
        self->getArea = Shape_getAreaImpl;
        self->draw = Shape_drawImpl;
    }
    return self;
}

void Shape_delete(Shape* self) {
    if (self) free(self);
}

// --- Circle 实现 ---
// Circle 专用的 getArea 实现
double Circle_getAreaImpl(Shape* self) {
    // 注意：这里传入的是 Shape 指针，需要强制转换为 Circle 指针来访问 radius
    // 因为 Shape 是 Circle 的第一个成员，所以 (Circle*)self 是合法的
    Circle* c = (Circle*)self; 
    return M_PI * c->radius * c->radius;
}

void Circle_drawImpl(Shape* self) {
    Circle* c = (Circle*)self;
    printf("Drawing a %s Circle with radius: %.2f\n", self->color, c->radius);
}

Circle* Circle_new(char* color, double radius) {
    Circle* self = (Circle*)malloc(sizeof(Circle));
    if (self) {
        // 初始化基类部分
        self->base.color = color; 
        self->base.getArea = Circle_getAreaImpl; // 重写（Override）函数指针
        self->base.draw = Circle_drawImpl;
        
        // 初始化子类部分
        self->radius = radius;
    }
    return self;
}

测试文件 main.c

#include "shape.h"

int main() {
    // 创建子类对象
    Circle* c = Circle_new("Red", 5.0);
    
    // 【多态的体现】
    // 虽然 c 是 Circle*，但我们可以将其视为 Shape* 传递给函数
    Shape* shapePtr = (Shape*)c; 
    
    // 调用虚函数，会根据实际绑定的函数指针执行
    shapePtr->draw(shapePtr);    // 输出: Drawing a Red Circle with radius: 5.00
    double area = shapePtr->getArea(shapePtr);
    printf("Area: %.2f\n", area); // 输出: Area: 78.54
    
    // 清理内存
    free(c);
    return 0;
}

2.3 常见问题解析：内存布局

问题：为什么Circle的第一个成员必须是Shape？ 解析：C语言标准规定，结构体变量的地址等于其第一个成员的地址。如果Shape不是第一个成员，强制转换(Shape*)circle将指向错误的内存位置，导致访问color或函数指针时发生内存错误（Segmentation Fault）。

---

第三部分：多态（Polymorphism）—— 动态绑定与虚函数表

3.1 理论基础

多态是指同一操作作用于不同类的实例时，产生不同的执行结果。在C语言中，多态是通过函数指针实现的。我们在基类结构体中定义函数指针成员，子类在初始化时将这些指针指向自己实现的函数。这就是动态绑定。

3.2 实践代码：扩展形状家族（矩形）

为了展示多态的威力，我们增加一个Rectangle类，并编写一个通用的render函数来处理所有形状。

扩展 shape.h 和 shape.c

Rectangle 定义 (shape.h):

typedef struct Rectangle {
    Shape base; // 继承
    double width;
    double height;
} Rectangle;

Rectangle* Rectangle_new(char* color, double w, double h);

Rectangle 实现 (shape.c):

double Rectangle_getAreaImpl(Shape* self) {
    Rectangle* r = (Rectangle*)self;
    return r->width * r->height;
}

void Rectangle_drawImpl(Shape* self) {
    Rectangle* r = (Rectangle*)self;
    printf("Drawing a %s Rectangle [%.2f x %.2f]\n", self->color, r->width, r->height);
}

Rectangle* Rectangle_new(char* color, double w, double h) {
    Rectangle* self = (Rectangle*)malloc(sizeof(Rectangle));
    if (self) {
        self->base.color = color;
        self->base.getArea = Rectangle_getAreaImpl;
        self->base.draw = Rectangle_drawImpl;
        self->width = w;
        self->height = h;
    }
    return self;
}

多态测试 main.c

#include "shape.h"

// 通用的处理函数：接收基类指针
void renderScene(Shape* shapes[], int count) {
    printf("=== Start Rendering Scene ===\n");
    double totalArea = 0.0;
    
    for (int i = 0; i < count; i++) {
        // 1. 多态调用 draw
        // 无论 shapes[i] 是 Circle 还是 Rectangle，这里都统一调用
        shapes[i]->draw(shapes[i]);
        
        // 2. 多态调用 getArea
        totalArea += shapes[i]->getArea(shapes[i]);
    }
    
    printf("Total Area of Scene: %.2f\n", totalArea);
    printf("=== End Rendering Scene ===\n");
}

int main() {
    // 创建不同类型的对象
    Circle* c = Circle_new("Blue", 10.0);
    Rectangle* r = Rectangle_new("Green", 4.0, 6.0);
    
    // 构建对象数组（注意：这里需要统一为 Shape* 类型）
    Shape* scene[] = {
        (Shape*)c,
        (Shape*)r
    };
    
    // 调用通用函数，体验多态
    renderScene(scene, 2);
    
    // 清理
    free(c);
    free(r);
    
    return 0;
}

输出结果分析：

=== Start Rendering Scene ===
Drawing a Blue Circle with radius: 10.00
Drawing a Green Rectangle [4.00 x 6.00]
Total Area of Scene: 314.16 + 24.00 = 338.16
=== End Rendering Scene ===

解析：renderScene函数并不知道具体的子类类型，它只调用draw和getArea。由于我们在构造对象时，将函数指针指向了具体的实现，程序在运行时自动执行了正确的逻辑。这就是多态。

---

第四部分：常见问题解析与最佳实践

在C语言中模拟面向对象时，初学者常会遇到以下问题：

4.1 虚函数表（vtable）的优化

在上面的例子中，每个Circle对象都包含一份函数指针（draw, getArea）。如果创建1000个Circle，就会有1000份相同的函数指针，浪费内存。 改进方案：使用静态的虚函数表（vtable）。

1. 定义一个结构体存放函数指针。
2. 在基类中只保留一个指向该表的指针。
3. 所有同类型的对象共享同一个表。

// 优化后的 Shape 结构
typedef struct ShapeVTable {
    double (*getArea)(Shape*);
    void (*draw)(Shape*);
} ShapeVTable;

struct Shape {
    ShapeVTable* vtable; // 指向虚表
    char* color;
};

// 使用时：
// shape->vtable->draw(shape);

4.2 类型安全问题

C语言的强制类型转换（(Shape*)）是不安全的。你可能会错误地将一个int*转换为Shape*并调用draw，导致程序崩溃。 建议：

• 在结构体中加入类型标识符（Magic Number）或签名字段。
• 在转换前进行检查。

typedef enum { TYPE_SHAPE, TYPE_CIRCLE, TYPE_RECT } ShapeType;

struct Shape {
    ShapeType type; // 标识类型
    // ... 其他成员
};

// 检查逻辑
if (obj->type == TYPE_CIRCLE) {
    Circle* c = (Circle*)obj;
    // 安全操作
}

4.3 构造与析构的复杂性

C语言没有自动调用父类构造函数和析构函数的机制。 建议：

• 手动链式调用：在子类构造函数中，显式调用父类构造函数。
• 析构顺序：遵循“先构造的后析构”原则。在Circle_delete中，先释放子类特有资源，再释放基类资源（如果基类有动态分配的内存）。

4.4 宏定义的使用

为了减少样板代码，可以使用宏来模拟构造和析构。

#define NEW(T, ...) T##_new(__VA_ARGS__)
#define DELETE(T, obj) T##_delete(obj)

// 使用
Circle* c = NEW(Circle, "Red", 5.0);
DELETE(Circle, c);

注意：过度使用宏会降低代码可读性，需谨慎。

总结

通过本次实验，我们深入探索了C语言的边界，利用结构体和函数指针实现了面向对象的三大支柱：

1. 封装：通过struct和不透明指针隐藏细节。
2. 继承：通过结构体成员布局和强制类型转换实现复用。
3. 多态：通过函数指针实现动态绑定。

虽然C语言没有原生的OO支持，但掌握这些技巧对于理解底层系统（如Linux内核驱动模型、GTK+图形库）的设计模式至关重要。在实际工程中，除非有极高的性能要求或受限于嵌入式环境，否则建议优先使用C++等原生支持面向对象的语言进行开发。