嵌入式软件开发的对象在哪（上）

面向对象的特征是抽象、封装、继承、多态，理论很多，前面关于软件设计思想的有多篇拙见，如《嵌入式软件的设计模式（上）》、《嵌入式软件的设计模式（下）》。对于嵌入式C软件开发采用面向对象的方法，只是停留在文字描述。结合个人经验和周立功《抽象接口技术和组件开发规范及其思想》，循序渐进的用代码范例说明，最好有一点点C++基础。间接说明理论指导实践的意义。纸上得来终觉浅，绝知此事要躬行。

1 面向对象编程基础

面向对象编程涉及到三个重要的特性：封装、继承与多态。部分 C 程序员，特别是嵌入式 C 程序员有一种误解，C 语言不是面向对象的编程语言，C++、Java、Python 等更高级的才是，使用 C 语言无法实现面向对象编程。这种误解致使他们没有动力学习一些优秀的面向对象编程方法，例如设计模式、设计原则、软件架构设计等等，进而很难开发出易维护、易部署、易重用、易管理的软件，很难面对项目需求的变更、扩展，很难开发和维护大型的复杂项目。

1.1 对象

面向对象编程，“对象”是整个编程过程的关键。其常见的解释是“数据与函数的组合”。每个对象都是由一组数据（用以描述对象的状态）和一组函数（对象支持的操作，用以描述对象的行为）组成的。对象实现了数据和操作的结合，使数据和操作可以封装于“对象”这个统一体中。

在面向过程编程中，程序设计注重的是“过程”，先做什么，后做什么；在外界看来，整个程序由一系列散乱的数据和函数组合而成。而在面向对象编程中，程序设计注重的是“对象”，在外界看来，整个程序由一系列“对象”块组合而成，数据和函数封装到了对象内部。

1.2 类

对象是有“类型”的，即类。“类”是对一组对象共性的抽象，表示一类对象，而对象是某个类的一个具体化的个例，通常称之为类的实例。对象通常是由数据和函数组成的，相应的类也具有两部分内容：属性（数据的抽象）和方法（对象行为的抽象）。

除了封装属性和操作外，类还具有访问控制的能力，如某些属性和方法是私有的，不能被外界访问。通过访问控制，能够对内部数据提供不同级别的保护，以防止外界意外地改变或使用私有部分。

1． 属性

类具有属性，它是对数据（对象的状态）的抽象。在 C 程序设计时，通常使用结构体类型来表示一个类，相关属性即包含在相应的结构体类型中。例如学生具有属性：姓名、学号、性别、身高、体重等信息，可以使用如下结构体类型表示“学生类”：

//微信公众号【嵌入式系统】
struct student
{
    char name[10];   /* 姓名 （假定最长10字符） */
    unsigned int id;  /* 学号 */
    char sex;    /* 性别:'M'，男；'F' ，女 */
    float height;   /* 身高 */
    float weight;   /* 体重 */
};
//微信公众号【嵌入式系统】提示，关于结构体、枚举等复杂类型定义推荐使用关键字 typedef

微信公众号【嵌入式系统】提示，关于结构体、枚举等复杂类型定义推荐使用关键字 typedef，更多C关键字了解可以参考《C语言关键字应用技巧》、《高质量嵌入式软件的开发技巧》。

2. 方法

类具有方法，它是对象行为的抽象，在 C 程序中，方法可以看作普通函数，不过其通常有一个特点 ，函数的第一个参数为类型的指针，指向了一个确定的对象，用以表明此次操作针对哪个对象，在方法实现时，即可通过该指针访问到对象中的各个属性。（微信公众号【嵌入式系统】这是C面向对象必须的，类似C++的this）

针对学生对象，为了对外展现学生自身的信息，自我介绍的格式是对外输出一个固定格式的字符串：

"Hi! My name is xxx, I'm a (boy/girl). My school number is xxx. My height is xxxcm and weight is xxxkg . "

其中的 xxx 对应学生实际的信息，基于此，可以为学生类定义并实现一个“自我介绍”的方法：

//微信公众号：嵌入式系统
void student_self_introduction(struct student *p_this)
{
    printf("Hi! My name is %s, I'm a %s. My school number is %d. My height is %fcm and weight is %fkg",
           p_this->name,
           (p_this->sex == 'M') ? "boy" : "girl",
           p_this->id,
           p_this->height,
           p_this->weight);
}

对于外界来讲，调用学生的“自我介绍”方法可以获知学生的全部信息。基于该类的定义，一个简易的应用程序范例详如下：

//微信公众号：嵌入式系统
void main(void)
{
    struct student chengj = {"chengj", 2024001, 'M', 173, 68};
    struct student hehe = {"hehe", 2024002, 'M', 150, 45};
    student_self_introduction(&chengj);
    student_self_introduction(&hehe);
    // ...
}

类中的方法 student_self_introduction 可以作用于任一学生类对象，对于程序员来讲，编写的代码将适用于一组对象，而非特定的某一个对象，提高了代码利用率。

在实际应用中，对比代码《嵌入式算法14---数据流与环形队列》，不少程序员都喜欢编写出一堆非常类似的接口，它们仅通过某一个数字后缀（0、1、2……）来区分，如系统使用到 3 个栈，初级程序员可能实现 3 个入栈函数，不良示意代码如下：

//微信公众号：嵌入式系统
//三个栈入栈的不良范例，引以为戒
int push_stack0(int data)
{
    //...
}

int push_stack1(int data)
{
    //...
}

int push_stack2(int data)
{
    //...
}

三个操作可能除了极小部分的差异外，其它处理完全相同，这就是没有面向对象编程的思维，没有定义对象类型的概念，将操作直接针对每个具体对象（栈 0、栈 1、栈 2），而不是一组同类的对象（所有栈对象）。显然，3个栈的特性和行为都基本类似，因而可以定义一个“栈类型”，如此一来，入栈操作将属于栈类型中的一个方法，适用于所有栈对象。例如：

//数据压入栈， p_stack 指向具体的栈对象
int push_stack(stack *p_stack, int data);

//微信公众号：嵌入式系统
//三个栈的入栈操作均可使用同一个方法
push_stack(p_stack0, 1);
push_stack(p_stack1, 2);
push_stack(p_stack2, 3);

这只是示意性代码，说明使用“类”的设计解决问题所带来的优势。

1.3 UML 类图

在面向对象的设计和开发过程中，通常使用 UML 工具来进行分析与设计。最基本的就是使用 UML 类图来表示类以及描述类之间的关系。

在 UML 类图中，一个矩形框表示一个类，矩形框内部被分隔为上、中、下三部分，上部为类的名字，中部为类的属性，下面部分为类的方法。对于属性和方法，还可以使用“+”、“-”修饰符来表示访问权限，“+”为公有属性、“-”为私有属性。如前面的学生类，其类名为 student，属性包括姓名、学号、性别、身高、体重，方法有“自我介绍”方法，则其对应的类图如下：通常情况下，类中的所有属性均为私有属性，不建议直接访问，所有属性的访问都通过类提供的方法。基于此，假定了学生类中的所有属性均为私有属性，因而在所有属性前都增加了“-”修饰符。

UML 类图主要用于辅助分析和设计，设计类时应聚焦在与当前问题有关的重要属性和行为，无关的属性和方法可去掉，确保简洁。由于私有属性仅在内部使用，外界无需关心，因此UML 类图中通常不体现私有属性和方法，除非某些特殊的私有属性和方法影响到问题的理解或者类的实现。基于此可以简化。2 封装

类是对一组对象共性的抽象，封装了属性和方法；即把一组关联的数据和函数圈起来，使圈外的代码只能看见部分函数，数据则完全不可见（微信公众号【嵌入式系统】一般建议数据的访问都应通过类提供的方法，而不是全局变量满天飞）。

2.1 “封装”示例

在C语言中，可使用一个 C 文件（*.c 文件）和 H 文件（*.h 文件）完成“类”的定义，将所有需要封装的东西都存于 C 文件中，H 文件中只展现“对外可见、无需封装”的内容。

以栈的实现为例，将所有实现代码都存于 C 文件中，H 文件只包含与栈相关接口的声明，比如入栈和出栈等。头文件和源文件的示意内容分别详见如下：

stack.h文件

#ifndef __STACK_H
#define __STACK_H
//微信公众号：嵌入式系统 所有头文件都必须防止重复引用

/* 类型声明，无需关心类定义的具体细节 */
struct stack;

/* 创建栈，并指定栈空间的大小*/
struct stack * stack_create(int size);

/* 入栈 */
int stack_push(struct stack *p_stack, int val);

/* 出栈 */
int stack_pop(struct stack *p_stack, int *p_val);

/* 删除栈 */
int stack_delete(struct stack *p_stack);

#endif

stack.c文件

//微信公众号：嵌入式系统
#include "stack.h"
#include "stdlib.h"

struct stack
{
    int top;   /* 栈顶*/
    int *p_buf;   /* 栈缓存*/
    unsigned int size;  /* 栈缓存的大小 */
};

unsigned int size; /* 栈缓存的大小*/

struct stack * stack_create(int size)
{
    struct stack *p_stack = (struct stack *)malloc(sizeof(struct stack));
    if(p_stack != NULL)
    {
        p_stack->top = 0;
        p_stack->size = size;

        p_stack->p_buf = (int *)malloc(sizeof(int) * size);
        if(p_stack->p_buf != NULL)
        {
            return p_stack;
        }
        free(p_stack); /* 分配栈内存失败*/
    }
    return NULL; /* 创建栈失败，返回 NULL*/
}

int stack_push(struct stack *p_stack, int val)
{
    if(p_stack->top != p_stack->size) //未满可入栈
    {
        p_stack->p_buf[p_stack->top++] = val;
        return 0;
    }
    return -1;
}

int stack_pop(struct stack *p_stack, int *p_val)
{
    if(p_stack->top != 0)  //非空可出栈
    {
        *p_val = p_stack->p_buf[--p_stack->top];
        return 0;
    }
    return -1;
}

int stack_delete(struct stack *p_stack)
{
    if(p_stack == NULL)
    {
        return -1;
    }

    if(p_stack->p_buf != NULL)
    {
        free(p_stack->p_buf);
    }
    free(p_stack);
    return 0;
}

使用 stack.h 的程序没有 struct stack 结构体成员的访问权限的，只能调用stack.h 文件中声明的方法。对于外界用户来说，struct stack 结构体的内部细节，以及各个函数的具体实现方式都是不可见的。这正是完美的封装！

由于所有细节都封装到了 C 文件内部，用户通过 stack.h 文件并不能看到 struct stack 结构体的具体定义，因此也无法访问 stack 结构体中的成员。若用户尝试访问 struct stack结构体中的成员，将会编译报错。（微信公众号【嵌入式系统】 C 语言不是面向对象的编程语言，实现封装有扩展性的牺牲）。

C语言实现封装的一般做法为：在头文件中进行数据结构以及函数定义的前置声明，在源文件中完成各函数的具体实现以及数据结构的定义。这样所有函数实现及定义细节均封装到了源文件中，对使用者来说是完全不可见的。

2.2 创建对象

2.2.1 内存分配的问题

基于前面创建栈方法，可以创建多个栈对象，例如：

struct stack *p_stack1 = stack_create(20);
struct stack *p_stack2 = stack_create(30);
struct stack *p_stack3 = stack_create(50);

每个栈对象需要两部分内存：

一是栈对象本身的内存（内存大小为 sizeof(struct stack)）；

二是该栈对象用于存储数据的缓存（内存大小为 sizeof(int) * size，其中，size 由用户在创建 栈时通过参数指定）。

在栈对象的创建函数中，使用 malloc()分配了该对象所需的内存空间，使用 malloc()分配内存空间非常方便，但这种做法也限制了对象内存的来源——必须使用动态内存。但对于嵌入式系统，内存往往是很大的瓶颈，很多应用场合可能并不太适合使用动态内存，主要有以下几个因素：

1)内存资源不足。运行嵌入式软件的硬件平台普遍内存小甚至只有几k RAM。这种条件下管理使用动态内存是比较浪费的行为，可能产生内存碎片，且内存分配的软件算法本身也会占用一定的内存空间。

2)实时性要求高。部分嵌入式应用对实时性要求很高，但由于资源的限制，集成的动态内存分配算法不是很完善，使得很难确保动态内存分配的实时性。

3)内存泄漏。动态内存分配可能出现内存泄漏。

4)软件编程复杂。在可靠的设计中，必须考虑内存分配失败的情况并对其进行异常处理，如果存在大量的动态内存分配，则处处都需考虑分配失败的情况。

将对象内存的来源限制为动态内存分配，限制了该类的应用场合，致使部分应用场合因为内存来源的问题不得不放弃该类的使用。

2.2.2 内存来源的探索

在 C 程序开发中，除了使用 malloc()得到一段内存空间外，还可以使用“直接定义变量”的形式分配一段内存。直接定义变量的形式，内存在编译阶段由编译器负责分配，无需用户作任何干预。根据变量定义位置的不同，实际内存的开辟位置存在一定的区别，主要有两类：

局部变量：内存开辟在栈中；静态变量（static 修饰的变量）或全局变量：内存开辟在全局静态存储区。

两种变量主要是生命周期的不同：局部变量在退出当前作用域后（比如函数返回），内存自动释放；静态变量或全局变量内存开辟在全局静态存储区，它们在程序的整个生命周期均有效。

内存可以有 3 种来源，它们的优缺点对比详见下表：

不同来源的内存各有优劣。前面提到，stack_create()函数将内存的来源限制为仅动态内存不太合理。为了避免内存来源受限，“内存的分配”这一步交由用户实现，以便用户根据实际需要自由选择内存的来源。基于此，可以将对象的创建拆分为两个独立的步骤，分配对象所需的内存和初始化对象。

2.2.3 分配对象所需的内存

内存分配的工作交由用户完成，以便用户根据实际需要自由选择。用户能够完成内存分配的前提是：用户知道应该分配的内存大小。前面提到，每个栈对象需要两部分内存：一是栈对象本身的内存（内存大小为：sizeof(struct stack)）；二是该栈对象用于存储数据的缓存（内存大小为 sizeof(int) * size，其中，size 由用户在创建栈时通过参数指定）。

1、栈对象本身的内存

栈对象本身的内存大小为 sizeof(struct stack)，若用户直接采用静态内存分配的方式（直接定义一个变量），则形式如下：

struct stack my_stack;

也可以继续采用动态内存的分配方式，例如：

struct stack *p_stack = (struct stack *)malloc(sizeof(struct stack));

但是，若将这两行代码直接放到主程序中会无法编译，因为之前描述的“封装”特性，使外界看不到 struct stack 的具体定义，也就是说，对于外界而言，该类型仅仅只是声明并未定义，该类型对应变量的大小对外也是未知的。

在 C 语言中定义一个变量时，编译器将负责该变量所占用内存的分配。内存的大小与类型相关，要完成变量内存的分配，编译器必须知道变量所占用的存储空间大小。当一个变量的类型未定义时，无法完成该类型对应变量的定义，因此，如下语句在编译时会出错：

struct stack my_stack;

同理，sizeof 语句用于获得相应类型数据的大小，而未定义的类型显然是不知道其大小的，动态内存分配中所使用的 sizeof(struct stack)语句也是错误的。

也许部分人会有疑问，既然该类型未定义，为什么在主程序中定义该类型的指针变量却可以呢？

struct stack *p_stack = //...

虽然 struct stack 类型未定义，但在之前已经声明，因此，编译器知道它是一个“合法的结构体类型”。此外，这里定义的是一个指针变量，在特定系统中，指针变量所占用的内存大小是确定的，例如，在 32 位系统中，指针通常占用 4 个字节。即指针变量所占用的内存空间大小与其指向的数据类型无关，编译器无需知道其指向的数据类型，就可完成指针变量内存的分配。因此，一个类型未定义，只要其声明了，就可以定义该类型的指针变量。但需要注意的是，在完成该类型的定义之前，不得尝试访问该指针所指向的内容。

完成内存的分配，提供三种方案。

（1） 将类的具体定义放到 H 文件中

为了使用户知道对象内存的大小，一种最简单的办法是直接将类型的定义放在 H 文件中。更新后的 H 文件示意代码如下：

stack.h文件

#ifndef __STACK_H
#define __STACK_H

/* 类型定义 */
struct stack
{
    int top;   /* 栈顶*/
    int *p_buf;   /* 栈缓存*/
    unsigned int size;  /* 栈缓存的大小 */
};

// ...... 其它函数声明
#endif

此时，对于外界，类型已经定义，如下语句均可正常使用：

struct stack my_stack;// 静态内存分配
struct stack *p_stack = (struct stack *)malloc(sizeof(struct stack));// 动态内存分配

由于类型的定义存放到了 H 文件中，暴露了类中的成员，在一定程度上破坏了类的“封装”性。此时外界可以直接访问类中的数据成员。牺牲一定的封装性，换来内存分配的灵活性，这也是在嵌入式系统中，基于 C 语言实现面向对象编程的一般做法（数据结构定义存放在 H 文件中更加符合程序员的编程风格）。嵌入式软件大多数类定义在 H文件中，并没有封装在 C 文件中。

虽然类的定义存放在 H 文件中，但出于封装性考虑，外界任何时候都不应直接访问对象中的数据，应该将其视为使用 C 语言实现面向对象编程的一条准则。软件开发需要遵守两个规则：一是在设计类时，应考虑到用户可能访问的数据，并为这些数据提供相应的访问接口；二是在使用别人提供的类时，除非有特殊说明，否则都不应该尝试直接访问类中的数据。

这种方法是目前嵌入式系统中使用得最为广泛的一种方法，因此后文使用这种方法讨论。

（2） 在 H 文件中定义一个新的结构体类型

为了继续保持类的封装性，类的定义依然保留在 C 文件中。只不过与此同时，在 H 文件中定义一个新的结构体类型。在该结构体类型中，各个成员的顺序和类型与类定义完全一致，仅命名不同。

struct stack_mem
{
    int dummy1;
    int *dummy2;
    unsigned int dummy3;
};

各成员的顺序和类型均与 struct stack 的定义完全相同，以此保证两个类型数据所需要的内存空间完全一致。同时，为了屏蔽各个成员的具体含义，所有成员均以 dummy 开头进行命名。对于外界来讲，可以基于 struct stack_mem 类型完成内存的分配，例如：

struct stack_mem my_stack;// 静态内存分配
struct stack *p_stack = (struct stack *)malloc(sizeof(struct stack_mem));// 动态内存分配

使用这种方案，类的实际定义依然没有暴露给外界，继续保持了良好的封装。（微信公众号【嵌入式系统】实际上FreeRTOS中，很多地方都采用了这种方法）。但这里定义了一个新的类型，给用户理解上造成了一定的困扰，此外，为确保两个类型完全一致，就要求类的设计者在修改类的定义时，必须确保 struct stack_mem 类型也同步修改，这给类的维护工作带来了挑战；稍有不慎，某一个类型没有同步修改就可能造成严重的错误，且这种错误编译器不会给出任何提示，非常隐蔽。关于代码审查可以参考《代码审查那些事》、《代码的保养》。

（3） 使用宏的形式告知对象所需的内存大小

既然外界只需要知道对象内存的大小，可以在开发过程中使用 sizoeof()获得struct stack 类型的大小，然后将其以宏的形式定义在 H 文件中。例如在 32 位系统中，使用 sizeof()获知 struct stack 类型的长度为 12，则可以在 H 文件中定义一个宏，例如：

#define STACK_MEM_SIZE 12

用户使用该宏完成内存分配，例如：

unsigned char stack_mem[STACK_MEM_SIZE];

这种做法仅仅在头文件中新增了一个宏定义，类的定义依然保持的 C 文件中，“封装”完全没有被破坏，看起来也非常完美。但这种做法也存在一些问题，因而很少采用。

a)对于同一个类型，不同系统中 sizeof()的结果可能不同。类型的长度与系统和编译器均相关。以 int 类型为例，在 32 位系统中为 32 位（4 字节），但 16 位系统中，其位宽可能为 16 位（2 字节）。因此，同样是 sizeof(int)，结果可能为 4，也可能为 2。使用 sizeof()获取类型的长度时，不同系统中获取的结果可能并不相同。这就导致 H 文件中的宏定义，切换平台需要重新测试验证。同时，由于类型的定义封装到了 C 文件中，因此修改过程只能有类的开发者完成，一般用户还无法完成，这就使得该类的跨平台特性很差，移植有风险。

b)内存不仅有大小的要求，还有内存对齐的要求。

因此，通过一个宏告知用户需要分配的内存空间大小并不是十分合适，会遇到跨平台、内存对齐等多个注意事项，用户可能在不经意间出错。在实际嵌入式系统中很少使用。一些编码技能可以参考《高质量嵌入式软件的开发技巧》。

2、存储数据的缓存

存储数据的缓存大小为 sizeof(int) *size，其中的 size 本身就是由用户指定的，这部分内存的大小用户很容易得知，进而完成内存的分配。可以采用静态内存分配的方式（直接定义一个变量）完成内存的分配：

int buf[20];

也可以采用动态内存分配的方式完成内存的分配：

int *p_buf = (int *)malloc(sizeof(int) * 20);

2.2.4 内存小曲

内存的来源主要有三种：动态内存、静态内存和栈内存，具体如何选择按实际情况。

一些入式应用对确定性要求较高，建议优先使用静态对象。如此一来只要能够编译（包含链接）成功，应用程序往往就可以按照确定的流程正确执行；若使用动态对象，则必须考虑对象创建失败的情况。偶尔使用的大块内存则建议使用动态内存，使用注意和防范可参考《动态内存管理及防御性编程》。

2.3 初始化对象

初始化对象的具体细节用户不需要关心，指定栈对象的地址、缓存地址及缓存大小，基于此，可以定义初始化函数的原型为：

int stack_init (struct stack *p_stack, int *p_buf, int size);

对于栈来讲，栈顶索引（top）的初始值恒为 0，因此该值无需通过初始化函数的参数传递。int 类型的返回值常用于表示执行的结果（微信公众号【嵌入式系统】建议非指针类型的返回值，以0表示成功，负数表示失败）。该函数的实现示意如下：

//微信公众号：嵌入式系统
int stack_init(struct stack *p_stack, int *p_buf, int size)
{
    p_stack->top = 0;
    p_stack->size = size;
    p_stack->p_buf = p_buf;
    return 0;
}

（微信公众号【嵌入式系统】该初始化函数的实现仅作为原理性展示，没有做过多的错误处理或参数检查，实际应用中，p_stack 为 NULL 或 p_buf 为 NULL 等情况都是错误情况，后续范例也会省去部分参数校验）。

至此，完成了将创建对象分离为“分配对象所需的内存”和“初始化对象”两个步骤，对象内存的来源交由用户决定，用户根据需要获得内存后，再将相关内存的首地址传递给初始化函数。

2.4 销毁对象

实现 stack_create()以及对应的stack_delete()，设计该函数的初衷是当一个栈对象不会再被使用时，可以通过该函数释放栈占用的资源，比如释放在 stack_create()函数中使用 malloc()分配的内存资源。

当将 stack_create()拆分为两步后，内存的分配将由用户决定，对应地内存的释放也应由用户决定。回顾 stack_delete()函数的实现，该函数目前只做了内存释放相关的操作，当不需要释放内存时，该函数看起来没有存在的必要。实际上，stack_delete()和 stack_create()函数是对应的，当将 stack_create()拆分为“分配对象所需的内存”和“初始化对象”两个步骤后，stack_delete()也应该相应的拆分为两个步骤：“释放对象占用的内存”和“解初始化对象”（微信公众号【嵌入式系统】解初始化或者反初始化，不用太在意这个操作的名称，只要理解表达的意思是初始化的逆过程即可，init：deinit，关于命名的英文集客参考《嵌入式软件命名常用英文集》）。

1． 释放对象占用的内存

前面已经提到，释放内存交由用户处理，释放方法与内存的来源相关。

动态内存的释放 动态内存分配应使用相应的释放内存函数（如 free()）进行释放。在释放时应确保分配的内存全部被有效释放。若某一部分内存被遗漏，将造成内存泄漏。随着程序的长期运行，内存不断泄漏可能导致系统崩溃。

静态内存的释放 使用静态内存（定义变量的形式），则内存的释放是系统自动完成的。若将对象定义为局部变量，内存开辟在系统栈中，则退出当前作用域后（函数返回）自动释放；若将对象定义为静态变量（static）或全局变量，则内存开辟在全局静态区，该区域的内存在应用程序的整个生命周期均有效，无法释放。

2． 解初始化对象

释放内存已交由用户处理，对于类的设计来讲，重点是设计“解初始化对象”对应的函数，该函数与 stack_init()函数对应，通常命名为“*_deinit”，即：stack_deinit()。该函数通常用于释放在初始化对象时占用的其它资源。

对于纯软件对象（与硬件无关的软件），通常其只会占用内存资源，不会额外占用其它资源，对这类对象解初始化时可能无需做任何事情。例如前面关于栈的实现，在stack_init()函数中仅对几个属性进行了赋值，没有额外占用其它任何资源，此时，stack_deinit()可能无需做任何事情，成为一个空函数。

int stack_deinit(struct stack *p_stack)
{
    return 0;
}

在嵌入式系统中，经常会遇到与硬件相关的对象，其初始化时往往会占用一定的硬件资源：I/O 引脚、系统中断、系统总线。在解初始化这种对象时，应同时释放占用的资源。可重点关注对象的初始化函数，查看其中是否分配、占用了某些资源。若有，则在解初始化函数中作相应的释放操作；若无，则解初始化函数留空。为了提高软件的简洁性，也可删除了空的解初始化函数，但这里为了展示软件结构，依然保留了解初始化函数。

将原 H 文件中的创建接口更新为初始化接口，删除接口更新为解初始化接口，更新后的 H 文件内容和 C 文件如下：

stack.h 文件

//微信公众号：嵌入式系统
#ifndef __STACK_H
#define __STACK_H

/* 类型定义*/
struct stack
{
    int top;   /* 栈顶*/
    int *p_buf;   /* 栈缓存*/
    unsigned int size;  /* 栈缓存的大小 */
};

/* 初始化*/
int stack_init(struct stack *p_stack, int *p_buf, int size);

/* 入栈*/
int stack_push(struct stack *p_stack, int val);

/* 出栈*/
int stack_pop(struct stack *p_stack, int *p_val);

/* 解初始化*/
int stack_deinit(struct stack *p_stack);

#endif

 stack.c 文件

//微信公众号：嵌入式系统
#include "stack.h"

int stack_init(struct stack *p_stack, int *p_buf, int size)
{
    p_stack->top = 0;
    p_stack->size = size;
    p_stack->p_buf = p_buf;
    return 0;
}

int stack_push(struct stack *p_stack, int val)
{
    if(p_stack->top != p_stack->size)
    {
        p_stack->p_buf[p_stack->top++] = val;
        return 0;
    }
    return -1;
}

int stack_pop(struct stack *p_stack, int *p_val)
{
    if(p_stack->top != 0)
    {
        *p_val = p_stack->p_buf[--p_stack->top];
        return 0;
    }
    return -1;
}

int stack_deinit(struct stack *p_stack)
{
    return 0;
}

3． 销毁对象的顺序

创建对象时是先分配对象所需内存，再初始化对象，因为在初始化对象时，需要传递相应内存空间的首地址作为初始化函数的参数。这就保证了在初始化对象之前，必须完成相关内存的分配。而销毁一个对象时，释放内存与调用解初始化函数并不能通过接口进行制约，销毁过程与创建恰恰相反，应先解初始化对象，再释放对象占用的内存。因为在解初始化对象时，还会使用到对象中的数据，若先释放对象占用的内存，则对象在被解初始化之前，就被彻底销毁了，对象已经不存在了，显然无法再进行解初始化操作。

若内存来源于动态内存分配，则完整的应用程序范例如下：

//微信公众号：嵌入式系统
#include "stack.h"
#include "stdio.h"
#include "stdlib.h"
int main()
{
    int val;
    struct stack *p_stack = (struct stack *)malloc(sizeof(struct stack));
    int *p_buf = (int *)malloc(sizeof(int) * 20);

 // 初始化
    stack_init(p_stack, buf, 20);

 //依次压入数据：2、4、5、8
    stack_push(p_stack, 2);
    stack_push(p_stack, 4);
    stack_push(p_stack, 5);
    stack_push(p_stack, 8);

 //依次弹出各个数据，并打印
    stack_pop(p_stack, &val);
    printf("%d ", val);
    stack_pop(p_stack, &val);
    printf("%d ", val);
    stack_pop(p_stack, &val);
    printf("%d ", val);
    stack_pop(p_stack, &val);
    printf("%d ", val);

 // 解初始化
    stack_deinit(p_stack);

 // 释放内存
    free(p_stack);
    free(p_buf);
 
    return 0;
}

若内存来源于静态内存分配，则内存的分配和释放完全由系统自行完成，如内存以“局部变量”的形式分配，范例程序如下：

//微信公众号：嵌入式系统
#include "stack.h"
#include "stdio.h"
int main()
{
    int val;
    int buf[20];
    struct stack stack;
    struct stack *p_stack = &stack;

    stack_init(p_stack, buf, 20);

 // 依次压入数据：2、4、5、8
    stack_push(p_stack, 2);
    stack_push(p_stack, 4);
    stack_push(p_stack, 5);
    stack_push(p_stack, 8);

 // 依次弹出各个数据，并打印
    stack_pop(p_stack, &val);
    printf("%d ", val);
    stack_pop(p_stack, &val);
    printf("%d ", val);
    stack_pop(p_stack, &val);
    printf("%d ", val);
    stack_pop(p_stack, &val);
    printf("%d ", val);

    stack_deinit(p_stack);
    return 0;
}

从形式上看，虽然栈类的代码变得复杂了一些，但对象内存的来源更具有灵活性，使得栈的适用范围更加广泛。在部分系统中，在保证对象内存来源不受限制的同时，为了特殊情况下的便利性，往往还保留了基于动态内存分配创建对象的方法，在这种情况下，将同时提供create 和 init 两套接口。

以 FreeRTOS 为例，其提供了两套创建任务的接口：xTaskCreate()和 xTaskCreateStatic()。其中，xTaskCreate()函数中采用动态内存分配的方法获得了任务相关内存；而 xTaskCreateStatic()函数即用于以“静态”的方式创建任务，任务相关的内存需要用户通过函数的参数传递（实际上该函数的作用就类似于 init 初始化函数，只不过其命名为了 Create）。freeRTOS可以作为RTOS开发入门的基础，具体可参考《FreeRTOS及其应用，万字长文，基础入门》、《基于RTOS的软件开发理论》。

在绝大部分面向对象编程语言中，也有类似于初始化和解初始化的接口，以C++为例，在定义类时，每个类都有构造函数和析构函数两个特殊的函数。构造函数就相当于这里的初始化函数，其在创建对象时自动调用；析构函数就相当于这里的解初始化函数，其在销毁对象时自动调用。例如，以局部变量的形式定义一个对象，则在定义对象时，会自动调用构造函数；在退出当前作用域（函数返回）时，会自动调用析构函数。高级的面向对象编程语言，为很多操作提供了语法特性上的原生支持，给实际编程带来了极大的便利。

3 继承

继承表示了一种类与类之间的特殊关系，即 is-a 关系，例如苹果是一种水果。A is-a B，表明了 A 只是 B 的一个特例，并不是 B 的全部，A（苹果）是子类，B（水果）是父类（又称基类、超类）。

子类是父类的一个特例，可以看作是在父类的基础上作了一些属性或方法的扩展，子类依然具有父类的属性和方法。使用继承关系在一个已经存在的类的基础上，定义一个新类。新类将自动继承已存在类的属性和方法，并可根据需要添加新的属性和方法。继承使子类可以重用父类中已经实现的属性和方法，无需再重复设计和编程，以此实现代码最大限度的复用。

3.1 “继承”示例

在 C 语言编程中，在定义子类（子类结构体类型）时，通过将父类作为子类的第一个成员实现继承。之所以这样做，是因为在 C 语言结构体中，第一个成员（父类）的地址和结构体自身（子类）的地址相同，当子类需要复用父类的方法时，子类的地址也可以作为父类的地址使用（微信公众号【嵌入式系统】这是后续继承操作取巧的基础）。

例如在一个系统中具有多个栈，为便于区分，每个栈可以具有不同的名称（系统栈、数据栈、符号栈……）。基于该需求，可以实现一个带名称的栈（为便于和前文普通栈区分，后文将其称为“命名栈”），即在普通栈的基础上，增加一个“名称”属性，该属性使每个栈都具有一个可供识别的名称，该栈类型的定义及接口声明如下：

stack_named.h文件

//微信公众号：嵌入式系统
#ifndef __STACK_NAMED_H
#define __STACK_NAMED_H

#include "stack.h"    /* 包含基类头文件*/

struct stack_named
{
    struct stack super;  /* 基类（超类）*/
    const char *p_name;  /* 栈名*/
};

/* 初始化 */
int stack_named_init(struct stack_named *p_stack, int *p_buf, int size, const char *p_name);

/* 设置名称*/
int stack_named_set(struct stack_named *p_stack, const char *p_name);

/* 获取名称*/
const char * stack_named_get(struct stack_named *p_stack);

/* 解初始化*/
int stack_named_deinit(struct stack_named *p_stack);

#endif

stack_named.c文件

//微信公众号：嵌入式系统
#include "stack_named.h"

int stack_named_init(struct stack_named *p_stack, int *p_buf, int size, const char *p_name)
{
    stack_init(&p_stack->super, p_buf, size); /* 初始化基类*/
    p_stack->p_name = p_name; /* 初始化子类成员 */
    return 0;
}

int stack_named_set(struct stack_named *p_stack, const char *p_name)
{
    p_stack->p_name = p_name;
    return 0;
}

const char * stack_named_get(struct stack_named *p_stack)
{
    return p_stack->p_name;
}

int stack_named_deinit(struct stack_named *p_stack)
{
    return stack_deinit(&p_stack->super); /* 解初始化基类*/
}

实现“命名栈”时，除初始化函数和解初始化函数外，仅为新增的属性p_name 提供了设置和获取方法，栈的核心逻辑相关函数（入栈、出栈）无需重复实现，入栈和出栈方法作为“命名栈”父类的方法，可以被复用。使用“命名栈”的应用程序范例如下：

//微信公众号：嵌入式系统
#include "stack_named.h"
#include "stdio.h"
int main()
{
    int val;
    int buf[20];
    struct stack_named stack_named;
    struct stack_named *p_stack_named = &stack_named;

    stack_named_init(p_stack_named, buf, 20, "chengj");
    printf("The stack name is %s!n", stack_named_get(p_stack_named));

    // 依次压入数据：2、4、5、8
    stack_push((struct stack *)p_stack_named, 2);  //强制栈类型转换
    stack_push((struct stack *)p_stack_named, 4);
    stack_push((struct stack *)p_stack_named, 5);
    stack_push((struct stack *)p_stack_named, 8);

    // 依次弹出各个数据，并打印
    stack_pop((struct stack *)p_stack_named, &val);  //强制栈类型转换
    printf("%d ", val);
    stack_pop((struct stack *)p_stack_named, &val);
    printf("%d ", val);
    stack_pop((struct stack *)p_stack_named, &val);
    printf("%d ", val);
    stack_pop((struct stack *)p_stack_named, &val);
    printf("%d ", val);

    stack_named_deinit(p_stack_named);
    return 0;
}

程序中，因为父类（struct stack）和子类（struct stack_named）对应的类型并不相同，所以当父类方法（stack_push()、stack_pop()）作用于子类对象（stack_named）时，为了避免编译器输出“类型不匹配”的警告，必须对类型进行强制转换。

在 C 语言中，大量的使用类型强制转换存在一定的风险，如两个类之间没有继承关系，使用强制转换将屏蔽编译器输出的警告信息，导致这类错误在编译阶段无法发现。为了避免使用强制类型转换，可以多做一步操作，从子类中取出父类的地址进行传递，保证参数类型一致：

stack_push((struct stack *)p_stack_named, 2);
//改为
stack_push(&p_stack_named->super, 2);

但无论使用哪种方法，看起来都不是很完美。这类问题的存在主要是因为 C语言并非真正的面向对象编程语言，使用 C 语言实现面向对象编程时，需要使用到一些看似“投机取巧”的手段。在真正的面向对象编程语言中，编译器可以识别继承关系，无需任何强制转换语句，父类的方法可以直接作用于子类。

3.2 初始化函数

回顾前面命名栈初始化函数：

int stack_named_init(struct stack_named *p_stack, int *p_buf, int size, const char *p_name)
{
    stack_init(&p_stack->super, p_buf, size); /* 初始化基类*/
    p_stack->p_name = p_name; /* 初始化子类成员 */
    return 0;
}

先调用了父类的初始化函数（stack_init()），再初始化命名栈特有的 p_name 属性。这里指出了一个隐含的规则：先初始化基类的成员，再初始化派生类特有的成员。该规则与面向对象编程语言中构造函数的调用顺序是一致的：在建立一个对象时，首先调用基类的构造函数，然后再调用派生类的构造函数。

3.3 解初始化函数

解初始化的顺序与初始化的顺序是恰好相反的，应先对派生类中特有的数据“解初始化”，再对基类作解初始化操作。解初始化函数的实现详见程序如下：

int stack_deinit(struct stack *p_stack)
{
    p_stack->top = 0;
    return 0;
}

int stack_named_deinit(struct stack_named *p_stack)
{
    p_stack->p_name = NULL;
    return stack_deinit(&p_stack->super); /* 解初始化基类在后*/
}

3.4 最少知识原则

所谓 “最少知识原则”就是，对使用者而言，不管类的内部如何，只调用提供的方法，其他的一概不管。（微信公众号【嵌入式系统】更多编码原则可以参考《嵌入式软件设计原则随想》）显然前面的“命名栈”并非如此，对于命名栈的使用者，其必须知道命名栈与普通栈之间的继承关系，进而才可以正确的使用普通栈的入栈方法，操作命名栈，例如：

stack_push((struct stack *)p_stack_named, 2); //类型转换关系

这对用户来说并不友好，因为其使用的是“命名栈”类（stack_named.h），却还要关心“普通栈”类（stack.h）。为满足“最少知识原则”，命名栈也可以提供入栈和出栈方法，使用户仅需关心命名栈的公共接口就可以完成命名栈的所有操作。

stack_named.h文件

#ifndef __STACK_NAMED_H
#define __STACK_NAMED_H

#include "stack.h"

/* 包含基类头文件*/

struct stack_named
{
    struct stack super; /* 基类（超类）*/
    const char *p_name; /* 栈名*/
};

/* 初始化 */
int stack_named_init(struct stack_named *p_stack, int *p_buf, int size, const char *p_name);

/* 设置名称 */
int stack_named_set(struct stack_named *p_stack, const char *p_name);

/* 获取名称 */
const char * stack_named_get(struct stack_named *p_stack);

//微信公众号：嵌入式系统
static inline int stack_named_push(struct stack_named *p_stack, int val)
{
    return stack_push(&p_stack->super, val);
}
static inline int stack_named_pop(struct stack_named *p_stack, int *p_val)
{
    return stack_pop(&p_stack->super, p_val);
}

/* 解初始化 */
int stack_named_deinit(struct stack_named *p_stack);

#endif

头文件中增加了两个方法：stack_named_push()和 stack_named_pop()，由于这两个函数非常简单，只是调用了其父类中相应的方法，仅一行代码，因而使用了内联函数的形式，如此可以优化代码大小和执行速度。经过简单的包装后，用户使用的所有方法都是作用于“命名栈”对象的，无需再使用类型强制转换等特殊的方法。更新后的“命名栈”使用范例片段如下：

// 压入数据
stack_named_push(p_stack_named, 2);

// 弹出数据并打印
stack_named_pop(p_stack_named, &val); printf("%d ", val);

从用户角度看，包装后的“命名栈”对用户来讲更加友好（无需类型强制转换）。但在实际开发过程中，若所有继承关系都再次封装一遍会显得累赘。因此，只对用户开放的类才需要这样做，如果某些类无需对用户开放，仅在内部使用，则可以酌情省略包装过程。

> 预知后事如何，且看下集分解 ...

嵌入式软件开发的对象在哪（下）