How can the C language implement modularity and object-oriented programming using malloc?

In the C language, although there is no concept of object-oriented programming, it is possible to simulate object-oriented features through techniques. One common method is to use the malloc function to implement modular and object-oriented thinking.

Here is a simple example demonstrating how to use the malloc function to achieve modular object-oriented programming.

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

// 定义一个结构体表示一个“类”
typedef struct {
    int value;
    void (*print)(void *self);
} MyClass;

// 定义一个函数，用于创建一个新的实例
MyClass *MyClass_create(int value) {
    MyClass *obj = (MyClass *)malloc(sizeof(MyClass));
    obj->value = value;
    obj->print = MyClass_print;
    return obj;
}

// 定义一个函数，用于销毁实例
void MyClass_destroy(MyClass *self) {
    free(self);
}

// 定义一个函数，用于打印实例的值
void MyClass_print(void *self) {
    MyClass *obj = (MyClass *)self;
    printf("Value: %d\n", obj->value);
}

int main() {
    // 创建一个新的实例
    MyClass *obj = MyClass_create(10);

    // 调用实例的打印方法
    obj->print(obj);

    // 销毁实例
    MyClass_destroy(obj);

    return 0;
}

In this example, we define a structure MyClass to represent a “class”, which includes an integer member called value and a function pointer called print for printing the value of the instance.

We use the MyClass_create function to create a new instance, assign values to the instance’s members and function pointers. Then we use the print method of the instance to print its value.

Finally, we utilize the MyClass_destroy function to free the memory of the instance.

In this way, we can achieve a simple modular object-oriented simulation. Of course, in actual projects, further encapsulation and abstraction can be implemented to achieve more complex object-oriented designs.