c语言入门25，使用c语言实现“类”的封装

第 14 节介绍了结构体，最近几节介绍了 C 语言的各种指针，基于这些内容，已经可以做一些比较有趣的事了。本节，我们将为 C 语言找一个“对象”，介绍一下 C 语言如何使用结构体和指针仿 C++ 实现“类”的封装。

malloc 和 free 函数

在正式开始本节内容之前，先介绍两个新函数。还记得第 5 节的这张图吗？当时我们提到，每调用一次函数，系统就会在栈中分配一块栈帧给被调用函数，当函数执行完毕后，这部分栈帧就自动被系统收回了。

malloc 的作用是申请一块指定大小的内存，它的原型如下，成功时返回这块内存的首地址，失败时返回 NULL。

// #include <stdlib.h>
void *malloc(size_t size);

函数局部变量占用的内存，是系统在函数运行时，自动在其所属栈帧中分配的，所以局部变量会随着系统在函数结束时回收栈帧时释放。不过，malloc 向系统申请的内存在堆区里，这部分内存不会随着函数的退出自动释放，需要程序员自己使用 free 函数释放：

char *p = (char*)malloc(5);
if(p)
    free(p);

以上几行代码的意思是向系统申请 5 字节的内存，如果申请成功，就把它释放。

如果整个程序执行完毕了，系统也会收回 malloc 申请的内存。如果在程序退出之前，只 malloc 而不 free，则程序占用的内存会越来越多，直到最后崩溃退出。这种情况，程序员习惯称为“内存泄漏”。

初学者如果对“面向对象”，“类”之类的名词没有概念，下面的可以不看。不过下面的内容也没有什么难的，归根结底，都是 C 语言指针的使用而已。

使用 C 语言实现“类”的封装

相当一部分程序员看不起 C 语言是因为他们觉得 C 语言没有“对象”。今天，我们尝试给 C 语言找一个“对象”。请看：

typedef struct _FATHER
{
    void       (*hello)();
}FATHER;

因为 C 无法定义 class，所以使用结构体来模仿 class。我们定义了一个“FATHER 类”，它有成员函数 hello。再看：

typedef struct _SON
{
    FATHER      *father;
    void            (*hello)(struct _SON* son);
    int               count;
}SON;

我们又定义了一个“SON 类”，它有成员函数 hello，也有成员变量 count，还有一个“父类”father。

初学者看到“类”感到陌生的话，就把它当做一个名词好了，说到底，还是 C 语言指针的使用。

接下来，定义“FATHER类”和“SON类”的 hello 函数：

void hello_father()
{
    printf("hello, i am father\n");
}
void hello_son(SON* son)
{
    son->count ++;
    printf("hello, i am son, count= %d\n", son->count);
}

如何让这两个函数与我们定义的“类”产生联系呢？我们定义“构造函数”：

SON* construct()
{
    SON* son = (SON*)malloc(sizeof(SON));
    son->father = (FATHER*)malloc(sizeof(FATHER));
    son->father->hello = hello_father;
    son->hello = hello_son;
    son->count = 0;
    return son;
}

首先使用 malloc 为 son 在堆中申请一块内存，这保证了 son 在程序结束之前都不会被释放。同样的，为 father 也申请了一块内存。接着，把它们各自的函数传递给结构体里面定义的函数指针。这样，我们便定义好了“类”son。

有了构造函数，我们再来定义“析构函数”：

int deconstruct(SON* son)
{
    if(son){
        if(son->father)
            free(son->father);
        free(son);
    }
    return 0;
}

析构函数的主要作用就是释放 malloc 的内存，防止内存泄漏。

至此，我们就使用 C 语言实现了“类”的封装，测试一下：

int main()
{
    SON* son = construct();
    son->hello(son);
    son->hello(son);
    son->father->hello();
    deconstruct(son);
    return 0;
}

编译执行，发现成功了。从表达式 son->hello(son) 可以看出，C 语言没有类的支持，我们需要显式的把 son 指针传给 hello。但是，“father类”和“son类”里都可以使用 hello 做函数名，这说明 C 语言的“类”也对封装有很好的效果。

到这里，我们就为 C 语言找到了“对象”。可以看出，C 语言真的非常灵活，当然，本篇文章只是抛砖引玉的介绍了 C 语言的冰山一角。