引言
C 语言诞生于 1972 年，已经走过 47 个年头了，可以说算是一门很陈旧的语言了，但现在仍然很流行，而且持续位于编程语言排行榜的前列，生命力非常旺盛。
C 语言经常被贴上 面向过程 的标签，很多同学都没想过或实践过用面向对象的思想来开发 C 语言的代码。当你的 C 系统比较简单时，用面向过程还是面向对象的思想来开发都可以，而当你的 C 系统比较庞大和复杂时，用面向对象的思想来开发则会显著提升系统的可理解性、可维护性和可扩展性。
本文以读者耳熟能详的一个设计模式（状态模式）为例，带领大家共同体验一段 C 语言的面向对象之旅，使得大家能快速掌握 C 语言的面向对象开发套路。
状态模式回顾
state-pattern.png
状态模式把对象的行为包装在不同的状态对象里，每一个状态对象都有一个共同的抽象状态类。当一个对象的内在状态改变时允许改变其行为，这个对象看起来是改变了其类。
使用场景：
- 一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为
- 代码中包含大量与对象状态有关的条件语句
上下文和状态处理对象：
- 在状态模式中，上下文是持有状态的对象，但上下文并不处理跟状态相关的行为，而是把处理状态的功能委托给了状态对应的状态处理类来处理
- 在具体的状态处理类中，经常需要获取上下文自身的数据，甚至在必要的时候回调上下文的方法，所以，通常将上下文自身当做参数传递给具体的状态处理类
C 语言实战
水有固态、液态和气态三种状态，而且这三种状态可以互相转化，如下图所示：
water.png
水有温度，我们可以认为：
- 当温度低于 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
{
ABSTRACT(void (*handle)(struct State* self, struct Water* water));
ABSTRACT(Boolean (*match)(struct State* self, int temperature));
const char* (*getName)(struct State* self);
char* name;
}State;
代码说明：
- 抽象类 State 的抽象方法 handle 中要回调 Water 指针的方法，所以需要前置声明 Water
- 抽象类 State 的抽象方法通过宏关键字
ABSTRACT来显式标记 - 抽象类 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 就够了，没有扩充的方法或属性需要再定义（如果子类需要扩充的话，则直接继续添加新成员即可）
- 具体子类必须实现抽象方法，同时复用继承的非抽象方法和属性
对象的生命周期管理
面向对象开发的一个核心思想就是对象，即把任何可以类型化的东西看成对象，而把程序之间的交互和调用以对象之间传递消息的形式来实现。对象如何创建及销毁，是对象的生命周期管理要关注的主要问题。
对象创建
我们通过 create 创建函数来模拟 C++ 中的 new 运算符：先申请对象内存，然后调用构造函数完成对象初始化。
对于 Water 对象，独立封装了创建函数 waterCreate 和构造函数 waterInit：
// Water.c
Water* waterCreate(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] = stateCreate(SOLID);
self->states[1] = stateCreate(LIQUID);
self->states[2] = stateCreate(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;
}
代码说明：
- waterCreate 的入参相当于构造函数的入参，是用户的初始化输入
- 当内存分配失败时，返回 NULL
- 在构造函数中可能会申请系统资源，当系统资源不足时，构造函数可能会失败，这时需要将返回值定义为 ErrCode 类型，这个与 C++ 的构造函数不同
- 构造函数的第一个参数必须为 this 指针
- 在 Water 的构造函数中调用了 State 的对象创建函数 stateCreate，对于具体子对象的创建，需要注入具体子类的枚举类型，而统一返回抽象类的指针
- Water 的属性 currentState 的初始化通过 waterChangeState 函数来动态完成，与用户输入的参数 temperature 强相关
对于 State 对象，统一封装了创建函数 stateCreate：
State* stateCreate(StateIdentifier identifier)
{
switch(identifier)
{
case SOLID: return solidStateCreate();
case LIQUID: return liquidStateCreate();
case GASEOUS: return gaseousStateCreate();
default: return NULL;
}
}
void stateInit(State* self,
void (*handle)(struct State* self, struct Water* water),
Boolean (*match)(struct State* self, int temperature),
char* name)
{
self->handle = handle;
self->match = match;
self->getName = stateGetName;
self->name = name;
}
State* solidStateCreate()
{
State* state = (State*)malloc(sizeof(SolidState));
if (state != NULL)
{
solidStateInit((SolidState*)state);
}
return state;
}
void solidStateInit(SolidState* self)
{
stateInit((State*)self, solidStateHandle, solidStateMatch, "SolidState");
}
代码说明：
- 创建函数 stateCreate 本质上是一个简单工厂：根据子类标识创建具体子类对象，而统一返回抽象类指针
- 创建函数 xStateCreate 用于创建具体子类的对象，并返回抽象类的指针
- 抽象类提供一个构造函数 stateInit，用来初始化抽象类声明的方法和属性，该构造函数仅能被具体子类的构造函数调用
- 每一个具体子类都要提供一个构造函数 xStateInit，完成子类对象的初始化，包括两部分：（1）调用基类的构造函数完成基类方法和属性的初始化；（2）独自完成该子类特有方法和属性的初始化
对象销毁
我们通过 destroy 销毁函数来模拟 C++ 中的 delete 运算符：先调用析构函数释放对象持有的资源，然后释放对象的内存。
对于 Water 对象，独立封装了销毁函数 waterDestroy 和析构函数 waterCleanUp：
void waterDestroy(Water* water)
{
waterCleanUp(water);
free(water);
}
void waterCleanUp(Water* self)
{
for (int i = 0; i < MAX_STATE_NUM; i++)
{
stateDestroy(self->states[i]);
self->states[i] = NULL;
}
self->currentState = NULL;
}
代码说明：
- 销毁函数和析构函数的入参都仅有 this 指针
- 析构函数释放对象持有资源的一个典型场景就是销毁对象持有的其他对象，然后将持有的对象指针置为 NULL
对于 State 对象，统一封装了销毁函数 stateDestroy：
void stateDestroy(State* state)
{
free(state);
}
代码说明：
- 销毁函数是必须的，而析构函数却是可选的，应根据具体情况来确定
- 具体子类对象的销毁统一复用抽象类的销毁函数 stateDestroy，即具体子类对象的创建函数 xStateCreate 不需要有对应的销毁函数
对象的多态
环境类 Water 持有抽象类 State 的指针：
// Water.h
struct State* states[MAX_STATE_NUM];
struct State* currentState;
在 Water 的构造函数中对这些 State 指针变量通过 State 的创建函数进行初始化：
self->states[0] = stateCreate(SOLID);
self->states[1] = stateCreate(LIQUID);
self->states[2] = stateCreate(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 = waterCreate(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);
waterDestroy(water);
}
运行程序，日志如下：
$ ./design-pattern-in-c state-pattern
LiquidState: 我性格温和，当前体温25摄氏度，我可滋润万物，饮用我可让你活力倍增……
LiquidState: 我性格温和，当前体温75摄氏度，我可滋润万物，饮用我可让你活力倍增……
SolidState: 我性格高冷，当前体温-25摄氏度，我坚如钢铁，仿如一冷血动物，请用我砸人……
GaseousState: 我性格热烈，当前体温175摄氏度，飞向天空是我毕生的梦想，在这你将看不到我的存在，我将达到无我的境界……
小结
至此，一段 C 语言的面向对象之旅已到达终点。
在这段奇妙的旅行中，我们掌握了一些用 C 语言实践面向对象思想的方法和技巧：
- 类的定义：用结构体来实现，通过函数指针来模拟方法
- 类的继承：将基类的变量作为子类的第一个成员，子类只能在父类的基础上扩展，可以理解为
里氏替换原则 - 对象的生命周期管理：主要讨论了对象创建和对象销毁
- 对象的多态：类型强转，是一种编译时多态
