10 多态:统一接口、行为分发与类型转换

C 语言面向对象系列

  1. 总纲:C 语言面向对象设计概览
  2. 封装:结构体与多实例接口
  3. 信息隐藏:公共接口与内部实现
  4. 模块组织:命名约定与对象生命周期
  5. 数据组织:实例状态、模块状态与常量
  6. HAL 实例:STM32 外设接口中的封装设计
  7. 结构体嵌套:公共数据与行为的复用
  8. 函数指针:可替换行为与回调
  9. 操作表:使用 ops 组织对象接口
  10. 多态:统一接口、行为分发与类型转换(当前篇)
  11. 接口约定:必选操作、可选操作与默认实现
  12. 框架整合:应用、驱动与平台的分层
  13. 工程扩展:自动注册与 Linux 内核中的对象组织

前面已经有了公共数据 base 和操作表 ops。本节将两者结合,让上层通过同一个 led_on() 接口操作 GPIO、PWM 或 RGB LED。

相同接口根据对象调用不同实现,这种用法称为多态。

将具体类型的选择放在对象中

如果上层分别判断 LED 类型,就需要调用不同函数:

1
2
3
4
5
6
7
if (type == LED_TYPE_GPIO) {
gpio_led_on(&gpio_led);
} else if (type == LED_TYPE_PWM) {
pwm_led_on(&pwm_led);
} else if (type == LED_TYPE_RGB) {
rgb_led_on(&rgb_led);
}

这段代码需要了解每种具体类型。新增一种 LED 时,还要修改上层分支。

使用操作表后,可以在初始化时将具体实现绑定到对象。上层调用统一入口,由对象的 ops 决定执行哪个函数。

取得对象的基础指针

具体类型中嵌入 LedBase_t:

1
2
3
4
typedef struct {
LedBase_t base;
uint8_t pwm_channel;
} PwmLed_t;

上层通过成员取址,取得基础部分的指针:

1
2
PwmLed_t pwm_led;
LedBase_t *led = &pwm_led.base;

这相当于设计上的向上转型:从具体对象取得公共部分。代码实际执行的是 &pwm_led.base,得到的类型就是 LedBase_t *。

取得地址还不代表对象已经可用;在调用操作接口前,仍需要完成具体对象的初始化。

在统一入口中检查并分发

将检查和操作表调用放入 led_on():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int led_on(LedBase_t *me)
{
if (me == NULL) {
return -1;
}

if (me->ops == NULL) {
return -2;
}

if (me->ops->on == NULL) {
return -3;
}

return me->ops->on(me);
}

函数先检查对象、操作表和 on 函数指针,再调用具体实现。按照操作表选择函数并执行的过程,通常称为分发(dispatch)。

调用过程如下:

1
2
3
led_on(led)
-> led->ops->on(led)
-> gpio_led_on / pwm_led_on / rgb_led_on

GPIO LED 的 ops->on 指向 gpio_led_on(),PWM LED 则指向 pwm_led_on()。上层始终调用 led_on(),无需重复选择设备类型。

它与 C++ 虚函数调用的共同点是统一入口、分别实现。这里的检查和分发由 C 代码显式完成。示例展示了指针检查,实际接口还应结合前面的生命周期约定处理初始化状态。

用基础指针数组管理多种 LED

管理器只保存 LedBase_t *,就可以容纳不同类型的 LED:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#define LED_MANAGER_MAX_COUNT 8

typedef struct {
LedBase_t *items[LED_MANAGER_MAX_COUNT];
uint8_t count;
} LedManager_t;

int led_manager_add(LedManager_t *me, LedBase_t *led)
{
if (me == NULL || led == NULL) {
return -1;
}

if (me->count >= LED_MANAGER_MAX_COUNT) {
return -2;
}

me->items[me->count++] = led;
return 0;
}

void led_manager_turn_all_on(LedManager_t *me)
{
if (me == NULL) {
return;
}

for (uint8_t i = 0; i < me->count; i++) {
led_on(me->items[i]);
}
}

添加对象时检查指针和容量;批量点亮时,依次调用统一接口。管理器不需要知道每个元素对应哪种硬件。

使用时,先初始化具体对象和管理器,再添加对象的基础指针:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
GpioLed_t gpio_led;
PwmLed_t pwm_led;
RgbLed_t rgb_led;

gpio_led_init(&gpio_led, 5);
pwm_led_init(&pwm_led, 6, 1);
rgb_led_init(&rgb_led, 7, 8, 9);

LedManager_t manager = {0};

led_manager_add(&manager, &gpio_led.base);
led_manager_add(&manager, &pwm_led.base);
led_manager_add(&manager, &rgb_led.base);

led_manager_turn_all_on(&manager);

这段调用示例省略了返回值处理。实际使用时,应检查初始化和添加操作的结果;管理器内部若需要处理点亮失败,也应检查 led_on() 的返回值。

从基础指针取得具体对象

具体实现有时需要访问基础结构体以外的成员。例如 PWM 操作需要读取 pwm_channel:

1
2
3
4
5
6
7
8
9
static int pwm_led_on(LedBase_t *base)
{
PwmLed_t *me = container_of(base, PwmLed_t, base);

me->base.is_on = true;
pwm_set_duty(me->pwm_channel, me->base.brightness);

return 0;
}

这里用 container_of(base, PwmLed_t, base) 从成员指针取得完整对象指针。简化实现如下:

1
2
#define container_of(ptr, type, member) \
((type *)((char *)(ptr) - offsetof(type, member)))

offsetof(type, member) 给出成员相对结构体起点的字节偏移,需要包含 <stddef.h>。用成员地址减去这个偏移,就得到结构体起始地址;转换为具体类型后,才能访问 pwm_channel。

这个过程要求传入的指针确实指向指定类型对象的指定成员。上例中的 base 必须来自一个有效的 PwmLed_t 对象,不能把 GPIO LED 的基础指针交给这段 PWM 实现。

这类操作常被称为向下转型。需要区分的是,本例的 container_of 只计算地址,不检查对象的实际类型;C++ 的 dynamic_cast 在相应的多态向下转换中会执行运行时检查。相关规则见 C++ 工作草案中的 dynamic_cast。

通过相同接口使用不同实现

完成初始化和绑定后,各种 LED 可以使用同一调用形式:

1
2
3
4
// 三种完全不同的 LED,同一套调用
led_on(&gpio_led.base); // -> gpio_led_on()
led_on(&pwm_led.base); // -> pwm_led_on()
led_on(&rgb_led.base); // -> rgb_led_on()

当新硬件符合现有接口约定时,上层可以继续使用 LedBase_t * 和统一接口,只增加具体实现及对象注册。这种方式适合需要管理多种设备的驱动框架,也可用于具有多种实现的协议接口。