C語言面向對象詳解

一、什麼是面向對象編程

面向對象編程(Object-Oriented Programming)是一種編程範式，它將現實世界中的事物（即對象）抽象成計算機程序中的數據類型，並通過定義對象之間的關係和交互來實現程序的設計和實現。

與面向過程編程相比，面向對象編程更加註重行為和關係的表達，能夠更加直觀地描述複雜的系統，並提供了良好的封裝性、繼承性和多態性等特性。

二、C語言的面向對象支持

雖然C語言沒有提供原生的面向對象支持，但通過一些技巧和手段，我們仍然可以用C語言來實現基本的面向對象特性。

1. 數據抽象

數據抽象(Data Abstraction)是面向對象編程的核心思想之一，它通過定義抽象數據類型來隱藏數據的實現細節，使得用戶只需關注數據的行為而不需要關注其具體實現方式。

C語言通過結構體和函數指針等手段可以很好地實現數據抽象。下面是一個基本的數據抽象例子：

// 定義抽象數據類型
typedef struct _Person
{
    char *name;
    int age;
    void (*say_hello)();
} Person;

// 定義函數指針
typedef void (*SayHelloFunc)();

// 實現具體行為
void say_hello_cn()
{
    printf("你好，世界！\n");
}

void say_hello_en()
{
    printf("Hello World!\n");
}

// 初始化對象
Person person = {"Tom", 20, say_hello_cn};

// 調用方法
person.say_hello(); // 輸出"你好，世界！"

// 修改對象的行為
person.say_hello = say_hello_en;
person.say_hello(); // 輸出"Hello World!"

2. 封裝

封裝(Encapsulation)是指將數據和行為組合成一個單獨的單元，並限制其他代碼直接訪問和修改這個單元的方式。

C語言通過結構體和函數指針等手段可以實現簡單的封裝。下面是一個封裝的例子：

// 定義結構體，用於存儲一些私有數據
typedef struct _LinkedListNode {
    int data;
    struct _LinkedListNode *next;
    struct _LinkedListNode *prev;
} LinkedListNode;

// 定義公共接口，只暴露部分行為給用戶
typedef struct _LinkedList {
    LinkedListNode *head;
    LinkedListNode *tail;
    int size;

    void (*insert)(struct _LinkedList *self, int data);
    void (*remove)(struct _LinkedList *self, int data);
} LinkedList;

// 實現接口的具體行為，使用函數指針調用私有方法
static void _insert(LinkedList *self, int data)
{
    LinkedListNode *node = malloc(sizeof(LinkedListNode));
    node->data = data;
    node->prev = self->tail;
    node->next = NULL;

    if (self->tail == NULL)
    {
        self->head = node;
        self->tail = node;
    }
    else
    {
        self->tail->next = node;
        self->tail = node;
    }

    self->size++;
}

static void _remove(LinkedList *self, int data)
{
    LinkedListNode *current = self->head;

    while (current != NULL)
    {
        if (current->data == data)
        {
            if (current->prev != NULL)
            {
                current->prev->next = current->next;
            }
            else
            {
                self->head = current->next;
            }

            if (current->next != NULL)
            {
                current->next->prev = current->prev;
            }
            else
            {
                self->tail = current->prev;
            }

            free(current);
            self->size--;
            break;
        }

        current = current->next;
    }
}

// 使用工廠函數封裝創建對象的細節
LinkedList *LinkedList_create()
{
    LinkedList *list = malloc(sizeof(LinkedList));
    list->head = NULL;
    list->tail = NULL;
    list->size = 0;

    list->insert = _insert;
    list->remove = _remove;

    return list;
}

// 客戶端代碼
LinkedList *list = LinkedList_create();
list->insert(list, 1);
list->insert(list, 2);
list->insert(list, 3);
list->remove(list, 2);

3. 繼承

繼承(Inheritance)是指通過創建一個子類來繼承父類的屬性和方法，並在其基礎上增加、修改或刪除一些行為。

在C語言中，我們可以使用結構體嵌套和函數指針來實現簡單的繼承。下面是一個繼承的例子：

// 定義父類，包含一些共有的行為
typedef struct _Animal
{
    char *name;

    void (*eat)();
    void (*sleep)();
} Animal;

// 定義子類，包含一些新增或者修改的行為
typedef struct _Cat
{
    Animal parent;
    char *color;

    void (*play)();
} Cat;

// 實現父類的行為
void animal_eat()
{
    printf("Animal is eating...\n");
}

void animal_sleep()
{
    printf("Animal is sleeping...\n");
}

// 實現子類的行為
void cat_play()
{
    printf("Cat is playing...\n");
}

// 工廠函數創建對象
Cat* cat_create(char *name, char *color)
{
    Cat *cat = malloc(sizeof(Cat));

    cat->parent.name = name;
    cat->parent.eat = animal_eat;
    cat->parent.sleep = animal_sleep;

    cat->color = color;
    cat->play = cat_play;

    return cat;
}

// 客戶端代碼
Cat *cat = cat_create("Tom", "white");
printf("name=%s, color=%s\n", cat->parent.name, cat->color); // 輸出"name=Tom, color=white"
cat->parent.eat(); // 輸出"Animal is eating..."
cat->play(); // 輸出"Cat is playing..."

4. 多態

多態(Polymorphism)是指不同的對象可以對同一消息做出不同的響應。

在C語言中，通過函數指針和結構體嵌套等技巧可以實現簡單的多態。下面是一個多態的例子：

// 定義共有接口
typedef struct _Shape
{
    char *type;

    float (*area)(struct _Shape *self);
} Shape;

// 定義子類，實現具體的行為
typedef struct _Rectangle
{
    Shape parent;
    float width;
    float height;
} Rectangle;

float rectangle_area(Rectangle *self)
{
    return self->width * self->height;
}

// 定義子類，實現具體的行為
typedef struct _Circle
{
    Shape parent;
    float radius;
} Circle;

float circle_area(Circle *self)
{
    return 3.14 * self->radius * self->radius;
}

// 工廠函數創建對象
Rectangle *rectangle_create(float width, float height)
{
    Rectangle *shape = malloc(sizeof(Rectangle));
    shape->parent.type = "Rectangle";
    shape->parent.area = (float (*)(Shape *))rectangle_area;
    shape->width = width;
    shape->height = height;

    return shape;
}

Circle *circle_create(float radius)
{
    Circle *shape = malloc(sizeof(Circle));
    shape->parent.type = "Circle";
    shape->parent.area = (float (*)(Shape *))circle_area;
    shape->radius = radius;

    return shape;
}

// 客戶端代碼
Shape *shapes[2];
shapes[0] = (Shape *)rectangle_create(10, 20);
shapes[1] = (Shape *)circle_create(20);

for (int i = 0; i type, shapes[i]->area(shapes[i]));
}