引言

C 语言诞生于 1972 年，已经走过 47 个年头了，可以说算是一门很陈旧的语言了，但现在仍然很流行，而且持续位于编程语言排行榜的前列，生命力非常旺盛。

C 语言经常被贴上面向过程的标签，很多同学都没想过或实践过用面向对象的思想来开发 C 语言的代码。当你的 C 系统比较简单时，用面向过程还是面向对象的思想来开发都可以，而当你的 C 系统比较庞大和复杂时，用面向对象的思想来开发则会显著提升系统的可理解性、可维护性和可扩展性。
本文以读者耳熟能详的一个设计模式（状态模式）为例，带领大家共同体验一段 C 语言的面向对象之旅，使得大家能快速掌握 C 语言的面向对象开发套路。

状态模式回顾

状态模式把对象的行为包装在不同的状态对象里，每一个状态对象都有一个共同的抽象状态类。当一个对象的内在状态改变时允许改变其行为，这个对象看起来是改变了其类。

使用场景：

一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为
代码中包含大量与对象状态有关的条件语句
上下文和状态处理对象：
在状态模式中，上下文是持有状态的对象，但上下文并不处理跟状态相关的行为，而是把处理状态的功能委托给了状态对应的状态处理类来处理
在具体的状态处理类中，经常需要获取上下文自身的数据，甚至在必要的时候回调上下文的方法，所以，通常将上下文自身当做参数传递给具体的状态处理类

C 语言实战
水有固态、液态和气态三种状态，而且这三种状态可以互相转化，如下图所示：

水有温度，我们可以认为：

当温度低于 0 度时，则水是固态
当温度高于等于 0 度而低于 100 度时，则水是液态
当温度高于等于 100 度时，则水是气态

类的设计

Water 类：环境类，持有状态对象的集合
State 类：抽象类，声明了所有状态对象的公共行为
SolidState：具体子类，水的状态为固态
LiquidState：具体子类，水的状态为液态
GaseousState：具体子类，水的状态为气态
类图和设计模式中完全一样，不再赘述。

类的定义
在 C 语言中只能用结构体 struct 来模拟类，而类有属性和方法：

struct 中没有方法，我们用函数指针来模拟
struct 中有数据成员，我们来模拟类的属性
struct 只能是 public 的，即方法和属性都是公有的

Water 类定义，代码示例：

//  Water.h

struct State;

typedef struct Water
{
    int (*getTemperature)(struct Water* self);
    void (*riseTemperature)(struct Water* self, int step);
    void (*reduceTemperature)(struct Water* self, int step);
    void (*behavior)(struct Water* self);
    void (*changeState)(struct Water* self);
    struct State* states[MAX_STATE_NUM];
    struct State* currentState;
    int temperature;
} Water;

代码说明：

Water 持有多个 State 指针，所以需要前置声明 State
所有方法都用函数指针来模拟，且第一个参数 self 模拟 this 指针，这里参数名使用 self 而不是 this 的原因是为了防止 C 与 C++ 混编时出现编译问题，而平台的基础子系统或模块不会涉及 C 与 Python 的混编
先定义方法，然后是属性
当温度变化（rise 或 reduce）时，会触发 changeState 操作，从而及时更新属性 currentState 的值

类的继承
具体子类继承抽象类的方法和属性，即具体子类声明的方法和属性以抽象类的声明为基础，然后根据实际需要再扩充。考虑将抽象类的变量作为具体子类的第一个成员，这样抽象类指针和具体子类指针都可以指向具体子类对象的地址。
抽象类代码示例：

// State.h

struct Water;

typedef struct State
{
    VIRTUAL(void (*handle)(struct State* self, struct Water* water));
    VIRTUAL(Boolean (*match)(struct State* self, int temperature));
    const char* (*getName)(struct State* self);
    char* name;
}State;

代码说明：

抽象类 State 的抽象方法 handle 中要回调 Water 指针的方法，所以需要前置声明 Water
抽象类 State 的抽象方法通过宏关键字 VIRTUAL 来显式标记
抽象类 State 的非抽象方法，在该抽象类中实现，具体子类继承相关方法

直接复用
具体子类 SolidState、LiquidState 和 GaseousState 都继承抽象类 State，代码示例：

// State.h

typedef struct SolidState
{
    State base;
}SolidState;

typedef struct LiquidState
{
    State base;
}LiquidState;

typedef struct GaseousState
{
    State base;
}GaseousState;

代码说明：
具体类仅继承抽象类 State 就够了，没有扩充的方法或属性需要再定义（如果子类需要扩充的话，则直接继续添加新成员即可）
具体类必须实现抽象方法，同时复用继承的非抽象方法和属性

对象的生命周期管理
面向对象开发的一个核心思想就是对象，即把任何可以类型化的东西看成对象，而把程序之间的交互和调用以对象之间传递消息的形式来实现。对象如何创建及销毁，是对象的生命周期管理要关注的主要问题。

对象创建
我们通过 newObj 创建函数来模拟 C++ 中的 new 运算符：先申请对象内存，然后调用构造函数完成对象初始化。
对于 Water 对象，独立封装了创建函数 newWater 和构造函数 waterInit：

// Water.c

Water* newWater(int temperature)
{
    Water* water = (Water*)malloc(sizeof(Water));
    if (water != NULL)
    {
        ErrCode err = waterInit(water, temperature);
        if (err != ERR_SUCC)
        {
            return NULL;
        }
    }
    return water;
}

ErrCode waterInit(Water* self, int temperature)
{
    self->states[0] = newState(SOLID);
    self->states[1] = newState(LIQUID);
    self->states[2] = newState(GASEOUS);
    for (int i = 0; i < MAX_STATE_NUM; i++)
    {
        if (self->states[i] == NULL)
        {
            return ERR_MEM_MALLOC_FAILED;
        }
    }
    self->temperature = temperature;
    waterChangeState(self);
    self->getTemperature = waterGetTemperature;
    self->riseTemperature = waterRiseTemperature;
    self->reduceTemperature = waterReduceTemperature;
    self->changeState = waterChangeState;
    self->behavior = waterBehavior;
    return ERR_SUCC;
}

代码说明：
newWater 的入参相当于构造函数的入参，是用户的初始化输入
当内存分配失败时，返回 NULL
在构造函数中可能会申请系统资源，当系统资源不足时，构造函数可能会失败，这时需要将返回值定义为 ErrCode 类型，这个与 C++ 的构造函数不同
构造函数的第一个参数必须为 this 指针
在 Water 的构造函数中调用了 State 的对象创建函数 newState，对于具体子对象的创建，需要注入具体子类的枚举类型，而统一返回抽象类的指针
Water 的属性 currentState 的初始化通过 waterChangeState 函数来动态完成，与用户输入的参数 temperature 强相关
同理，对于 State 对象，独立封装了创建函数 newState 和具体子类的构造函数 solidStateInit，liquidStateInit 和 gaseousStateInit：

State* newState(StateIdentifier identifier)
{
    State* state = NULL;
    switch(identifier)
    {
    case SOLID:
        state = (State*)malloc(sizeof(SolidState));
        if (state != NULL)
        {
            solidStateInit((SolidState*)state);
        }
        break;

    case LIQUID:
        state = (State*)malloc(sizeof(LiquidState));
        if (state != NULL)
        {
            liquidStateInit((LiquidState*)state);
        }
        break;

    case GASEOUS:
        state = (State*)malloc(sizeof(GaseousState));
        if (state != NULL)
        {
            gaseousStateInit((GaseousState*)state);
        }
        break;

    default:
        break;
    }

    return state;
}

void solidStateInit(SolidState* self)
{
    self->base.name = "SolidState";
    self->base.getName = stateGetName;
    self->base.match = solidStateMatch;
    self->base.handle = solidStateHandle;
}

代码说明：

创建函数 newState 本质上是一个简单工厂：根据子类标识创建具体子类对象，而统一返回抽象类指针
每一个具体子类都要提供一个构造函数，完成三件事：（1）注入抽象类的抽象方法在该子类的实现（2）注入抽象类的具体方法直接复用；（3）初始化该子类独有的方法和属性；

对象销毁
我们通过 deleteObj 销毁函数来模拟 C++ 中的 delete 运算符：先调用析构函数释放对象持有的资源，然后释放对象的内存。
对于 Water 对象，独立封装了销毁函数 deleteWater 和析构函数

waterCleanUp：
void deleteWater(Water* water)
{
    waterCleanUp(water);
    free(water);
}

void waterCleanUp(Water* self)
{
    for (int i = 0; i < MAX_STATE_NUM; i++)
    {
        deleteState(self->states[i]);
        self->states[i] = NULL;
    }
    self->currentState = NULL;
}

代码说明：

销毁函数和析构函数的入参都仅有 this 指针
析构函数释放对象持有资源的一个典型场景就是销毁对象持有的其他对象，然后将持有的对象指针置为 NULL
同理，对于 State 对象，独立封装了销毁函数 deleteState：

void deleteState(State* state)
{
    free(state);
}

代码说明：销毁函数是必须的，而析构函数却是可选的，应根据具体情况来确定
对象的多态
环境类 Water 持有抽象类 State 的指针：

// Water.h

struct State* states[MAX_STATE_NUM];
struct State* currentState;

在 Water 的构造函数中对这些 State 指针变量通过 State 的创建函数进行初始化：

self->states[0] = newState(SOLID);
self->states[1] = newState(LIQUID);
self->states[2] = newState(GASEOUS);

for (int i = 0; i < MAX_STATE_NUM; i++)
{
    if (self->states[i]->match(self->states[i], self->temperature))
    {
        self->currentState = self->states[i];
        return;
    }
}

可以看出，抽象类指针指向了具体子类对象的地址。在宏模拟的继承基础上，仅仅通过类型强转就能轻松实现多态。就这么简单？对，就这么简单，而且这种多态本质上是一种编译时多态。

客户端调用
客户端调用的过程：

创建 Water 对象，初始温度设置为 25 摄氏度，则水是液态，具有液态的行为
将水的温度升高 50 摄氏度，则温度变为 75 摄氏度，水仍然是液态，具有液态的行为
将水的温度再降低 100 摄氏度，则温度变为 -25 摄氏度，水是固态，具有固态的行为
将水的温度再升高 200 摄氏度，则温度变为 175 摄氏度，水是气态，具有气态的行为
销毁 Water 对象

客户端代码的示例：

// Client.c

void statePatternRun()
{
    Water* water = newWater(25);
    if (water == NULL) return;

    water->behavior(water);
    water->riseTemperature(water, 50);
    water->behavior(water);
    water->reduceTemperature(water, 100);
    water->behavior(water);
    water->riseTemperature(water, 200);
    water->behavior(water);

    deleteWater(water);
}

运行程序，日志如下：

$ ./design-pattern-in-c state-pattern
$ ./design-pattern-in-c state-pattern

LiquidState: 我性格温和，当前体温25摄氏度，我可滋润万物，饮用我可让你活力倍增……
LiquidState: 我性格温和，当前体温75摄氏度，我可滋润万物，饮用我可让你活力倍增……
SolidState: 我性格高冷，当前体温-25摄氏度，我坚如钢铁，仿如一冷血动物，请用我砸人……
GaseousState: 我性格热烈，当前体温175摄氏度，飞向天空是我毕生的梦想，在这你将看不到我的存在

小结

至此，一段 C 语言的面向对象之旅已到达终点。
在这段奇妙的旅行中，我们掌握了一些用 C 语言实践面向对象思想的方法和技巧：

类的定义：用结构体来实现，通过函数指针来模拟方法
类的继承：用宏来实现，要保证子类完全遵守父类的约定，子类只能在父类的基础上扩展，可以理解为里氏替换原则
对象的生命周期管理：主要讨论了对象创建和对象销毁
对象的多态：类型强转，是一种编译时多态
案例代码链接

本文转载自技术琐话公众号。

原文链接：https://mp.weixin.qq.com/s/VOTiOYQGr6Xn7ouNzdXWuw

创作场景

用 C 语言玩面向对象