模块的封装（二）：C语言类的继承和派生

落日映苍穹つ 2022-09-26 04:56 693阅读 0赞

出处：

\[交流\]\[微知识\]模块的封装（二）：C语言类的继承和派生

--------------------

在模块的封装（一）：C语言类的封装中，我们介绍了如何使用C语言的结构体来实现一个类的封装，并通过掩码结构体的方式实  
现了类成员的保护。这一部分，我们将在此基础上介绍C语言类的继承和派生。其实继承和派生是同一个动作的两种不同角度的表述。  
当我们继承了一个基类而创造了一个新类时，派生的概念就诞生了。派生当然是从基类派生的。派生出来的类当然继承了基类的东西。  
继承和派生不是一对好基友，他们根本就是一个动作的两种不同说法，强调动作的起始点的时候，我们说这是从某某类继承来的；强调  
动作的终点时，我们说派生出了某某类。——呼……真累……厄……不是阿……我不是唐僧。  
  
我们知道，类总是会提供一些方法，可以让我们很方便的使用，比如

1.    
    
2.   window\_t tWin = new\_window(); //!< 创建一个新的window对象  
    
3.   tWin.show(); //!< 显示窗体  
    
4.

复制代码

显然，能够实现这一技术的必要手段就是将函数指针一起封装在结构体中。在C语言中，类的方法（method）是通过函数指针（或者函  
数指针的集合）——我们叫做虚函数（表）来实现的。虚函数表同样可以单独存在，我们称之为interface。在C语言中，虚函书表是可以  
直接通过封装了纯函数指针的结构体来实现的。如下面的代码所示：

1.  //! \\name interface definition  
    
2.  //! @\{  
    
3.  \#define DEF\_INTERFACE(\_\_NAME,...) \\  
    
4.   typedef struct \_\_NAME \_\_NAME;\\  
    
5.   \_\_VA\_ARGS\_\_\\  
    
6.   struct \_\_NAME \{  
    
7.    
    
8.  \#define END\_DEF\_INTERFACE(\_\_NAME) \\  
    
9.   \};  
    
10. //! @\}  
    
11.

复制代码

例如，我们可以使用上面的宏来定义一个字节流的读写接口：

1.    
    
2.  DEF\_INTERFACE(i\_pipe\_byte\_t)  
    
3.   bool (\*write)(uint8\_t chByte);  
    
4.   bool (\*read)(uint8\_t \*pchByte)  
    
5.  END\_DEF\_INTERFACE(i\_pipe\_byte\_t)  
    
6.

复制代码

这类接口非常适合定义一个模块的依赖型接口——比如，某一个数据帧解码的模块是依赖于对字节流的读写的，通过在该模块中使用这样一个接口，  
并通过专门的接口注册函数，即可实现所谓的面向接口开发——将模块的逻辑实现与具体应用相关的数据流隔离开来。例如：  
  
frame.c

1.    
    
2.  ...  
    
3.  DEF\_CLASS(frame\_t)  
    
4.   i\_pipe\_byte\_t tStream; //!< 流接口  
    
5.   ...  
    
6.  END\_DEF\_CLASS(frame\_t)  
    
7.    
    
8.  //! 接口注册函数  
    
9.  bool frame\_register\_stream\_interface(frame\_t \*ptFrame, i\_pipe\_byte\_t tStream)  
    
10. \{  
    
11.  //! 去除掩码结构体的保护  
    
12.  CLASS(frame\_t) \*ptF = (CLASS(frame\_t) \*)ptFrame;  
    
13.  //! 合法性检查  
    
14.  if (NULL == tStream.write || NULL == tStream.read || NULL == ptFrame ) \{  
    
15.  return false;  
    
16.  \}  
    
17.  ptF->tStream = tStream; //!< 设置接口  
    
18.  return true;  
    
19. \}  
    
20.

复制代码

frame.h

1.    
    
2.  ...  
    
3.  EXTERN\_CLASS(frame\_t)  
    
4.   i\_pipe\_byte\_t tStream; //!< 流接口  
    
5.   ...  
    
6.  END\_EXTERN\_CLASS(frame\_t)  
    
7.    
    
8.  //! 接口注册函数  
    
9.  extern bool frame\_register\_stream\_interface(frame\_t \*ptFrame, i\_pipe\_byte\_t tStream);  
    
10.   
    
11. extern bool frame\_init(frame\_t \*ptFrame);  
    
12.   
    
13.

复制代码

基于这样的模块，一个可能的外部使用方法是这样的：  
app.c

1.    
    
2.  ...  
    
3.  static bool serial\_out(uint8\_t chByte)  
    
4.  \{  
    
5.   ...  
    
6.  \}  
    
7.    
    
8.  static bool serial\_in(uint8\_t \*pchByte)  
    
9.  \{  
    
10.  ...  
    
11. \}  
    
12.   
    
13. static frame\_t s\_tFrame;  
    
14. ...  
    
15. void app\_init(void)  
    
16. \{  
    
17.  //! 初始化  
    
18.  frame\_init(&s\_tFrame);  
    
19.   
    
20.  //! 初始化接口  
    
21.  do \{  
    
22.  i\_pipe\_byte\_t tPipe = \{&serial\_out, &serial\_in\};  
    
23.  frame\_register\_stream\_interface(&s\_tFrame, tPipe);  
    
24.  \} while(0);  
    
25. \}  
    
26.

复制代码

像这个例子展示的这样，将接口直接封装在掩码结构体中的形式，我们并不能将其称为“实现（implement）了接口i\_pipe\_byte\_t”，  
这只是内部将虚函数（表）表作为了一个普通的成员而已，我们可以认为这是加入了private属性的，可重载的内部成员函数。下面，我们  
将来介绍如何真正的“实现（implement）”指定的接口。首先，我们要借助下面的专门定义的宏：

1.    
    
2.  \#define DEF\_CLASS\_IMPLEMENT(\_\_NAME,\_\_INTERFACE,...)\\  
    
3.   typedef union \_\_NAME \_\_NAME;\\  
    
4.   \_\_VA\_ARGS\_\_\\  
    
5.   typedef struct \_\_\#\#\_\_NAME \_\_\#\#\_\_NAME;\\  
    
6.   struct \_\_\#\#\_\_NAME \{\\  
    
7.   const \_\_INTERFACE method;  
    
8.    
    
9.  \#define END\_DEF\_CLASS\_IMPLEMENT(\_\_NAME,\_\_INTERFACE)\\  
    
10.  \};\\  
    
11.  union \_\_NAME \{\\  
    
12.  const \_\_INTERFACE method;\\  
    
13.  uint\_fast8\_t chMask\[(sizeof(\_\_\#\#\_\_NAME) + sizeof(uint\_fast8\_t) - 1) / sizeof(uint\_fast8\_t)\];\\  
    
14.  \};  
    
15.   
    
16. \#define EXTERN\_CLASS\_IMPLEMENT(\_\_NAME,\_\_INTERFACE,...) \\  
    
17.  typedef union \_\_NAME \_\_NAME;\\  
    
18.  \_\_VA\_ARGS\_\_\\  
    
19.  union \_\_NAME \{\\  
    
20.  const \_\_INTERFACE method;\\  
    
21.  uint\_fast8\_t chMask\[(sizeof(struct \{\\  
    
22.  const \_\_INTERFACE method;  
    
23.   
    
24. \#define END\_EXTERN\_CLASS\_IMPLEMENT(\_\_NAME, \_\_INTERFACE) \\  
    
25.  \}) + sizeof(uint\_fast8\_t) - 1) / sizeof(uint\_fast8\_t)\];\\  
    
26.  \};  
    
27.   
    
28.

复制代码

为了很好的说明上面宏的用法，我们以一个比较具体的例子来示范一下。这是一个通用的串行设备驱动的例子，这个例子的  
意图是，为所有的类似USART，I2C，SPI这样的串行数据接口建立一个基类，随后，不同的外设都从该基类继承并派生出  
属于自己的基类，比如USART类等等——这种方法是面向对象开发尤其是面向接口开发中非常典型的例子。首先，我们要  
定义一个高度抽象的接口，该接口描述了我们是期待如何最简单的使用一个串行设备的，同时一起定义实现了该类的基类  
serial\_dev\_t:  
serial\_device.h

1.    
    
2.  //! 这是一个实现了接口i\_serial\_t的基类serial\_dev\_t  
    
3.  EXTERN\_CLASS\_IMPLEMENT( serial\_dev\_t, i\_serial\_t,  
    
4.    
    
5.   //! 这是我们定义的接口i\_serial\_t 这里的语法看起来似乎有点怪异，后面将介绍  
    
6.   DEF\_INTERFACE( i\_serial\_t)  
    
7.   fsm\_rt\_t (\*write)(serial\_dev\_t \*ptDev, uint8\_t \*pchStream, uint\_fast16\_t hwSize); //!< i\_serial\_t 接口的write方法  
    
8.   fsm\_rt\_t (\*read)(serial\_dev\_t \*ptDev, uint8\_t \*pchStream, uint\_fast16\_t hwSize); //!< i\_serial\_t 接口的read方法  
    
9.   END\_DEF\_INTERFACE( i\_serial\_t )  
    
10.  )  
    
11.  //! 类serial\_dev\_t的内部定义  
    
12.  ...  
    
13. END\_EXTERN\_CLASS\_IMPLEMENT( serial\_dev\_t, i\_serial\_t )  
    
14.

复制代码

如果不仔细看，这个例子似乎比较清楚了，一个基类serial\_dev\_t实现了接口i\_serial\_t。但仔细一看这里不光语法奇怪，  
而且还有很多细节。  
首先，接口居然是定义在类的定义里面的，而且是定义在参数宏EXTERN\_CLASS\_IMPLEMENT里面的！  
其次，似乎类serial\_dev\_t在接口i\_serial\_t定义之前就已经能implement它了，而且接口i\_serial\_t也反过来在自己的定义  
中引用了基类serial\_dev\_t。如果你曾经定义过类似下面的结构体，你就知道蹊跷在哪里了，同时，你也就知道解决的  
原理了：

1.    
    
2.  //! 一个无法编译通过的写法  
    
3.  typedef struct \{  
    
4.   ....  
    
5.   item\_t \*ptNext;  
    
6.  \}item\_t;  
    
7.

复制代码

等效的正确写法如下：

1.    
    
2.  //! 前置声明的例子  
    
3.  typedef struct item\_t item\_t;  
    
4.  struct item\_t \{  
    
5.   ...  
    
6.   item\_t \*ptNext;  
    
7.  \};  
    
8.

复制代码

可见，前置声明是解决这类问题的关键，回头再看看EXTERN\_CLASS\_IMPLEMENT的宏，你就会看到前置声明的结构。  
以此为例，我来演示一下如何用参数宏实现方便的前置声明：

1.    
    
2.  \#define DEF\_FORWARD\_LIST(\_\_NAME) \\  
    
3.   typedef struct \_\_NAME \_\_NAME;\\  
    
4.   struct \_\_NAME \{  
    
5.    
    
6.  \#define END\_DEF\_FORWARD\_LIST(\_\_NAME) \\  
    
7.   \};  
    
8.

复制代码

使用的时候这样

1.    
    
2.  DEF\_FORWARD\_LIST(item\_t)  
    
3.   ...  
    
4.   item\_t \*ptNext;  
    
5.  END\_DEF\_FORWARD\_LIST(item\_t)  
    
6.

复制代码

这只解决了一个疑惑，另外一个疑惑就是为什么可以在参数宏里面插入另外一段代码？答案是一直可以，比如，我常这么干：

1.    
    
2.  \# define SAFE\_ATOM\_CODE(...) \{\\  
    
3.   istate\_t tState = GET\_GLOBAL\_INTERRUPT\_STATE();\\  
    
4.   DISABLE\_GLOBAL\_INTERRUPT();\\  
    
5.   \_\_VA\_ARGS\_\_;\\  
    
6.   SET\_GLOBAL\_INTERRUPT\_STATE(tState);\\  
    
7.   \}  
    
8.

复制代码

这是原子操作的宏，使用的时候，只要在"..."的位置写程序就好了，例如：  
adc.c

1.    
    
2.  ...  
    
3.  static volatile uint16\_t s\_hwADCResult;  
    
4.  ...  
    
5.  ISR(ADC\_vect)  
    
6.  \{  
    
7.   //! 获取ADC的值  
    
8.   s\_hwADCResult = ADC0;  
    
9.  \}  
    
10.   
    
11. //! \\brief 带原子保护的adc结果读取  
    
12. uint16\_t get\_adc\_result(void)  
    
13. \{  
    
14.  uint16\_t hwResult;  
    
15.  SAFE\_ATOM\_CODE(  
    
16.  hwResult = s\_hwResult;  
    
17.  )  
    
18.  return hwResult;  
    
19. \}  
    
20.

复制代码

adc.h

1.    
    
2.  ...  
    
3.  //! 可以随时安全的读取ADC的结果  
    
4.  extern uint16\_t get\_adc\_result(void);  
    
5.  ...  
    
6.

复制代码

现在看来在参数宏里面插入大段大段的代码根本不是问题，问题是，当我不想插入的时候怎么办呢？例如这个例子里面，宏  
EXTERN\_CLASS\_IMPLEMENT(\_\_NAME, \_\_INTERFACE,...)这里，我们真正关心的是\_\_NAME和\_\_INTERFACE，而是否插入  
其它代码到定义结构里面是不确定的，我们很可能就直接想这么用

1.    
    
2.  EXTERN\_CLASS\_IMPLEMENT(example\_t, i\_serial\_t)  
    
3.  ....  
    
4.  END\_EXTERN\_CLASS\_IMPLEMENT(example\_t, i\_serial\_t)  
    
5.

复制代码

显然，这时候变长参数就成了关键，幸好C99位我们提供了这个便利，直接在参数宏里面加入“...”在宏本体里面用  
\_\_VA\_ARGS\_\_就可以代表“...”的内容了。  
  
经过这样的解释，回头再去看前面的类定义，根本不算什么。^\_^  
那么一个类实现（implement）了某个接口，这有神马意义呢？ 意义如下，我们就可以像正常类那么使用接口提供的方法了：

1.    
    
2.  //! 假设我们获取了一个名叫“usart0”的串行设备  
    
3.  serial\_dev\_t \*ptDev = get\_serial\_device("usart0");  
    
4.    
    
5.  uint8\_t chString\[\] = "Hello World!";  
    
6.    
    
7.  //! 我们就可以访问这个对象的方法，比如发送字符串  
    
8.  while ( fsm\_rt\_cpl !=  
    
9.   ptDev->method.write(ptDev, chString, sizeof(chString))  
    
10. );  
    
11. //! 当然这个对象仍然是被掩码结构体保护的，因为ptDev的另外一个可见的成员是ptDev->chMask，你懂的  
    
12.

复制代码

接下来，我们要处理的问题就是继承和派生……唉，绕了这么大的圈子，才切入本文的重点。记得有个谚语的全文叫做“博士卖驴，  
下笔千言，离题万里，未有驴子……”  
要实现继承和派生，只要借助下面这个装模作样的宏就可以了。

1.    
    
2.  //! \\brief macro for inheritance  
    
3.  \#define INHERIT(\_\_TYPE) \_\_TYPE base;  
    
4.

复制代码

是的，它不过是把基类作为新类（结构体）的第一个元素，并起了一个好听的名字叫base。“尼玛坑爹了吧？”没错，其实就是这  
样，没什么复杂的，所以我们可以很容易的从serial\_dev\_t继承并为usart派生一个类出来：  
usart.h

1.    
    
2.  \#include "serial\_device.h"  
    
3.  ...  
    
4.  EXTERN\_CLASS(usart\_t) INHERIT(serial\_dev\_t)  
    
5.    
    
6.   uint8\_t chName\[20\]; //!< 保存名字，比如"USART0"  
    
7.   usart\_reg\_t \*ptRegisters; //!< 指向设备寄存器  
    
8.   ...  
    
9.    
    
10. END\_EXTERN\_CLASS(usart\_t)  
    
11.   
    
12. //! \\brief 当然要提供一个函数来返回基类咯  
    
13. extern serial\_dev\_t \*usart\_get\_base(usart\_t \*ptUSART);  
    
14.

复制代码

完成了这些，关于OOC格式上的表面工作，基本上就介绍完毕了。格式毕竟是表面工作，学会这些并不能让你的代码面向对象，  
最多时看起来很高档。真正关键的是给自己建立面向对象的思维模式和训练自己相应的开发方法，这就需要你去看那些介绍面向  
对象方法的书了，比如面向对象的思想啊，设计模式阿，UML建模阿。还是那句老话，如果你不知道怎么入门，看《UML+OOPC》。  
  
打完手工，谢谢~

一个绘图无关的 窗体系统的例子

--------------------

window.h

1.    
    
2.    
    
3.  //! \\name 矩形区域  
    
4.  //! @\{  
    
5.  typedef struct \{  
    
6.   int32\_t nTop;  
    
7.   int32\_t nLeft;  
    
8.   int32\_t nHeigh;  
    
9.   int32\_t nWidth;  
    
10. \} rect\_t;  
    
11. //! @\}  
    
12.   
    
13.   
    
14.   
    
15. //! \\brief 定义一个window类，它是一切的起点，也是一个抽象类abstract class，实现了接口i\_win\_t  
    
16. EXTERN\_CLASS\_IMPLEMENT(window\_t,i\_win\_t,  
    
17.  //! \\name 基于接口开发的window当然要有对应的接口咯，这也是未来覆盖（override）的关键  
    
18.  DEF\_INTERFACE(i\_win\_t,  
    
19.  fsm\_rt\_t win\_method\_t(window\_t \*ptWin); //!< window类里面的会用到的虚函数原型  
    
20.  fsm\_rt\_t win\_msg\_process(window\_t \*ptWin, msg\_t tMSG); //!< 消息处理函数  
    
21.  )  
    
22.  win\_method\_t \*fnRefresh; //!< 一个虚函数，用来刷新窗体的，你懂的  
    
23.  win\_msg\_process \*fnMSGProcess; //!< 一个虚函数 窗体怎么能没有消息处理函数呢，这可是事件驱动的关键阿  
    
24.  END\_DEF\_INTERFACE  
    
25. )  
    
26.  rect\_t tRegion; //!< window的位置和大小  
    
27.  bool bIsPressed; //!< 是否是被按下的效果  
    
28. END\_EXTERN\_CLASS\_IMPLEMENT(window\_t,i\_win\_t)  
    
29.   
    
30.

复制代码

control.h

1.    
    
2.    
    
3.  //! \\name 一个抽象类，它继承了基类window\_t  
    
4.  EXTERN\_CLASS(control\_t) INHERIT(window\_t)  
    
5.    
    
6.   bool bIsTableStop; //!< Table键是否能停在这个控件上  
    
7.   bool bIsActivated; //!< 当前控件是否处于激活状态  
    
8.   i\_control\_t \*ptPrevious;  
    
9.   i\_control\_t \*ptNext;  
    
10.   
    
11. END\_EXTERN\_CLASS(control\_t)  
    
12.   
    
13.

复制代码