一文了解嵌入式軟件開發(fā)的對象

以前應用場景很單一，嵌入式開發(fā)可能談不上面向?qū)ο箝_發(fā)。但現(xiàn)在，做嵌入式開發(fā)，沒有面向?qū)ο箝_發(fā)，你就有點落伍了。

本文結(jié)合個人經(jīng)驗和周立功《抽象接口技術和組件開發(fā)規(guī)范及其思想》，循序漸進的用代碼范例說明嵌入式軟件開發(fā)的對象，前提你最好有一點點C++基礎。間接說明理論指導實踐的意義。

紙上得來終覺淺，絕知此事要躬行。

1 面向?qū)ο?a href="http://wenjunhu.com/v/tag/1315/" target="_blank">編程基礎

面向?qū)ο缶幊躺婕暗饺齻€重要的特性：封裝、繼承與多態(tài)。部分 C 程序員，特別是嵌入式 C 程序員有一種誤解，C 語言不是面向?qū)ο蟮木幊陶Z言，C++、Java、Python 等更高級的才是，使用 C 語言無法實現(xiàn)面向?qū)ο缶幊獭＿@種誤解致使他們沒有動力學習一些優(yōu)秀的面向?qū)ο缶幊谭椒?，例如設計模式、設計原則、軟件架構(gòu)設計等等，進而很難開發(fā)出易維護、易部署、易重用、易管理的軟件，很難面對項目需求的變更、擴展，很難開發(fā)和維護大型的復雜項目。

1.1 對象

面向?qū)ο缶幊蹋皩ο蟆笔钦麄€編程過程的關鍵。其常見的解釋是“數(shù)據(jù)與函數(shù)的組合”。每個對象都是由一組數(shù)據(jù)（用以描述對象的狀態(tài)）和一組函數(shù)（對象支持的操作，用以描述對象的行為）組成的。對象實現(xiàn)了數(shù)據(jù)和操作的結(jié)合，使數(shù)據(jù)和操作可以封裝于“對象”這個統(tǒng)一體中。

在面向過程編程中，程序設計注重的是“過程”，先做什么，后做什么；在外界看來，整個程序由一系列散亂的數(shù)據(jù)和函數(shù)組合而成。而在面向?qū)ο缶幊讨?，程序設計注重的是“對象”，在外界看來，整個程序由一系列“對象”塊組合而成，數(shù)據(jù)和函數(shù)封裝到了對象內(nèi)部。

1.2 類

對象是有“類型”的，即類?！邦悺笔菍σ唤M對象共性的抽象，表示一類對象，而對象是某個類的一個具體化的個例，通常稱之為類的實例。對象通常是由數(shù)據(jù)和函數(shù)組成的，相應的類也具有兩部分內(nèi)容：屬性（數(shù)據(jù)的抽象）和方法（對象行為的抽象）。

除了封裝屬性和操作外，類還具有訪問控制的能力，如某些屬性和方法是私有的，不能被外界訪問。通過訪問控制，能夠?qū)?nèi)部數(shù)據(jù)提供不同級別的保護，以防止外界意外地改變或使用私有部分。

1． 屬性

類具有屬性，它是對數(shù)據(jù)（對象的狀態(tài)）的抽象。在 C 程序設計時，通常使用結(jié)構(gòu)體類型來表示一個類，相關屬性即包含在相應的結(jié)構(gòu)體類型中。例如學生具有屬性：姓名、學號、性別、身高、體重等信息，可以使用如下結(jié)構(gòu)體類型表示“學生類”：

//微信公眾號【嵌入式系統(tǒng)】
structstudent
{
charname[10];/*姓名（假定最長10字符）*/
unsignedintid;/*學號*/
charsex;/*性別:'M'，男；'F'，女*/
floatheight;/*身高*/
floatweight;/*體重*/
};
//提示，關于結(jié)構(gòu)體、枚舉等復雜類型定義推薦使用關鍵字typedef

提示，關于結(jié)構(gòu)體、枚舉等復雜類型定義推薦使用關鍵字 typedef，更多C關鍵字了解可以參考《C語言關鍵字應用技巧》、《高質(zhì)量嵌入式軟件的開發(fā)技巧》。

2. 方法

類具有方法，它是對象行為的抽象，在 C 程序中，方法可以看作普通函數(shù)，不過其通常有一個特點 ，函數(shù)的第一個參數(shù)為類型的指針，指向了一個確定的對象，用以表明此次操作針對哪個對象，在方法實現(xiàn)時，即可通過該指針訪問到對象中的各個屬性。（微信公眾號【嵌入式系統(tǒng)】這是C面向?qū)ο蟊仨毜模愃艭++的this）

針對學生對象，為了對外展現(xiàn)學生自身的信息，自我介紹的格式是對外輸出一個固定格式的字符串：

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

其中的 xxx 對應學生實際的信息，基于此，可以為學生類定義并實現(xiàn)一個“自我介紹”的方法：

voidstudent_self_introduction(structstudent*p_this)
{
printf("Hi!Mynameis%s,I'ma%s.Myschoolnumberis%d.Myheightis%fcmandweightis%fkg",
p_this->name,
(p_this->sex=='M')?"boy":"girl",
p_this->id,
p_this->height,
p_this->weight);
}

對于外界來講，調(diào)用學生的“自我介紹”方法可以獲知學生的全部信息?；谠擃惖亩x，一個簡易的應用程序范例詳如下：

voidmain(void)
{
structstudentchengj={"chengj",2024001,'M',173,68};
structstudenthehe={"hehe",2024002,'M',150,45};
student_self_introduction(&chengj);
student_self_introduction(&hehe);
//...
}

類中的方法 student_self_introduction 可以作用于任一學生類對象，對于程序員來講，編寫的代碼將適用于一組對象，而非特定的某一個對象，提高了代碼利用率。

在實際應用中，對比代碼《嵌入式算法14---數(shù)據(jù)流與環(huán)形隊列》，不少程序員都喜歡編寫出一堆非常類似的接口，它們僅通過某一個數(shù)字后綴（0、1、2……）來區(qū)分，如系統(tǒng)使用到 3 個棧，初級程序員可能實現(xiàn) 3 個入棧函數(shù)，不良示意代碼如下：

//三個棧入棧的不良范例，引以為戒
intpush_stack0(intdata)
{
//...
}

intpush_stack1(intdata)
{
//...
}

intpush_stack2(intdata)
{
//...
}

三個操作可能除了極小部分的差異外，其它處理完全相同，這就是沒有面向?qū)ο缶幊痰乃季S，沒有定義對象類型的概念，將操作直接針對每個具體對象（棧 0、棧 1、棧 2），而不是一組同類的對象（所有棧對象）。顯然，3個棧的特性和行為都基本類似，因而可以定義一個“棧類型”，如此一來，入棧操作將屬于棧類型中的一個方法，適用于所有棧對象。例如：

//數(shù)據(jù)壓入棧，p_stack指向具體的棧對象
intpush_stack(stack*p_stack,intdata);

//微信公眾號：嵌入式系統(tǒng)
//三個棧的入棧操作均可使用同一個方法
push_stack(p_stack0,1);
push_stack(p_stack1,2);
push_stack(p_stack2,3);

這只是示意性代碼，說明使用“類”的設計解決問題所帶來的優(yōu)勢。

1.3 UML 類圖

在面向?qū)ο蟮脑O計和開發(fā)過程中，通常使用 UML 工具來進行分析與設計。最基本的就是使用 UML 類圖來表示類以及描述類之間的關系。

在 UML 類圖中，一個矩形框表示一個類，矩形框內(nèi)部被分隔為上、中、下三部分，上部為類的名字，中部為類的屬性，下面部分為類的方法。對于屬性和方法，還可以使用“+”、“-”修飾符來表示訪問權(quán)限，“+”為公有屬性、“-”為私有屬性。如前面的學生類，其類名為 student，屬性包括姓名、學號、性別、身高、體重，方法有“自我介紹”方法，則其對應的類圖如下：

通常情況下，類中的所有屬性均為私有屬性，不建議直接訪問，所有屬性的訪問都通過類提供的方法。基于此，假定了學生類中的所有屬性均為私有屬性，因而在所有屬性前都增加了“-”修飾符。

UML 類圖主要用于輔助分析和設計，設計類時應聚焦在與當前問題有關的重要屬性和行為，無關的屬性和方法可去掉，確保簡潔。由于私有屬性僅在內(nèi)部使用，外界無需關心，因此UML 類圖中通常不體現(xiàn)私有屬性和方法，除非某些特殊的私有屬性和方法影響到問題的理解或者類的實現(xiàn)?；诖丝梢院喕?。

2 封裝

類是對一組對象共性的抽象，封裝了屬性和方法；即把一組關聯(lián)的數(shù)據(jù)和函數(shù)圈起來，使圈外的代碼只能看見部分函數(shù)，數(shù)據(jù)則完全不可見（微信公眾號【嵌入式系統(tǒng)】一般建議數(shù)據(jù)的訪問都應通過類提供的方法，而不是全局變量滿天飛）。

2.1 “封裝”示例

在C語言中，可使用一個 C 文件（*.c 文件）和 H 文件（*.h 文件）完成“類”的定義，將所有需要封裝的東西都存于 C 文件中，H 文件中只展現(xiàn)“對外可見、無需封裝”的內(nèi)容。

以棧的實現(xiàn)為例，將所有實現(xiàn)代碼都存于 C 文件中，H 文件只包含與棧相關接口的聲明，比如入棧和出棧等。頭文件和源文件的示意內(nèi)容分別詳見如下：

stack.h文件

#ifndef__STACK_H
#define__STACK_H
//微信公眾號：嵌入式系統(tǒng)所有頭文件都必須防止重復引用

/*類型聲明，無需關心類定義的具體細節(jié)*/
structstack;

/*創(chuàng)建棧，并指定?？臻g的大小*/
structstack*stack_create(intsize);

/*入棧*/
intstack_push(structstack*p_stack,intval);

/*出棧*/
intstack_pop(structstack*p_stack,int*p_val);

/*刪除棧*/
intstack_delete(structstack*p_stack);

#endif

stack.c文件

//微信公眾號：嵌入式系統(tǒng)
#include"stack.h"
#include"stdlib.h"

structstack
{
inttop;/*棧頂*/
int*p_buf;/*棧緩存*/
unsignedintsize;/*棧緩存的大小*/
};

unsignedintsize;/*棧緩存的大小*/

structstack*stack_create(intsize)
{
structstack*p_stack=(structstack*)malloc(sizeof(structstack));
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)
{
returnp_stack;
}
free(p_stack);/*分配棧內(nèi)存失敗*/
}
returnNULL;/*創(chuàng)建棧失敗，返回NULL*/
}

intstack_push(structstack*p_stack,intval)
{
if(p_stack->top!=p_stack->size)//未滿可入棧
{
p_stack->p_buf[p_stack->top++]=val;
return0;
}
return-1;
}

intstack_pop(structstack*p_stack,int*p_val)
{
if(p_stack->top!=0)//非空可出棧
{
*p_val=p_stack->p_buf[--p_stack->top];
return0;
}
return-1;
}

intstack_delete(structstack*p_stack)
{
if(p_stack==NULL)
{
return-1;
}

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

使用 stack.h 的程序沒有 struct stack 結(jié)構(gòu)體成員的訪問權(quán)限的，只能調(diào)用stack.h 文件中聲明的方法。對于外界用戶來說，struct stack 結(jié)構(gòu)體的內(nèi)部細節(jié)，以及各個函數(shù)的具體實現(xiàn)方式都是不可見的。這正是完美的封裝！

由于所有細節(jié)都封裝到了 C 文件內(nèi)部，用戶通過 stack.h 文件并不能看到 struct stack 結(jié)構(gòu)體的具體定義，因此也無法訪問 stack 結(jié)構(gòu)體中的成員。若用戶嘗試訪問 struct stack結(jié)構(gòu)體中的成員，將會編譯報錯。（微信公眾號【嵌入式系統(tǒng)】C 語言不是面向?qū)ο蟮木幊陶Z言，實現(xiàn)封裝有擴展性的犧牲）。

C語言實現(xiàn)封裝的一般做法為：在頭文件中進行數(shù)據(jù)結(jié)構(gòu)以及函數(shù)定義的前置聲明，在源文件中完成各函數(shù)的具體實現(xiàn)以及數(shù)據(jù)結(jié)構(gòu)的定義。這樣所有函數(shù)實現(xiàn)及定義細節(jié)均封裝到了源文件中，對使用者來說是完全不可見的。

2.2 創(chuàng)建對象

2.2.1 內(nèi)存分配的問題

基于前面創(chuàng)建棧方法，可以創(chuàng)建多個棧對象，例如：

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

每個棧對象需要兩部分內(nèi)存：

一是棧對象本身的內(nèi)存（內(nèi)存大小為 sizeof(struct stack)）；

二是該棧對象用于存儲數(shù)據(jù)的緩存（內(nèi)存大小為 sizeof(int) * size，其中，size 由用戶在創(chuàng)建 棧時通過參數(shù)指定）。

在棧對象的創(chuàng)建函數(shù)中，使用 malloc()分配了該對象所需的內(nèi)存空間，使用 malloc()分配內(nèi)存空間非常方便，但這種做法也限制了對象內(nèi)存的來源——必須使用動態(tài)內(nèi)存。但對于嵌入式系統(tǒng)，內(nèi)存往往是很大的瓶頸，很多應用場合可能并不太適合使用動態(tài)內(nèi)存，主要有以下幾個因素：

1)內(nèi)存資源不足。運行嵌入式軟件的硬件平臺普遍內(nèi)存小甚至只有幾k RAM。這種條件下管理使用動態(tài)內(nèi)存是比較浪費的行為，可能產(chǎn)生內(nèi)存碎片，且內(nèi)存分配的軟件算法本身也會占用一定的內(nèi)存空間。

2)實時性要求高。部分嵌入式應用對實時性要求很高，但由于資源的限制，集成的動態(tài)內(nèi)存分配算法不是很完善，使得很難確保動態(tài)內(nèi)存分配的實時性。

3)內(nèi)存泄漏。動態(tài)內(nèi)存分配可能出現(xiàn)內(nèi)存泄漏。

4)軟件編程復雜。在可靠的設計中，必須考慮內(nèi)存分配失敗的情況并對其進行異常處理，如果存在大量的動態(tài)內(nèi)存分配，則處處都需考慮分配失敗的情況。

將對象內(nèi)存的來源限制為動態(tài)內(nèi)存分配，限制了該類的應用場合，致使部分應用場合因為內(nèi)存來源的問題不得不放棄該類的使用。

2.2.2 內(nèi)存來源的探索

在 C 程序開發(fā)中，除了使用 malloc()得到一段內(nèi)存空間外，還可以使用“直接定義變量”的形式分配一段內(nèi)存。直接定義變量的形式，內(nèi)存在編譯階段由編譯器負責分配，無需用戶作任何干預。根據(jù)變量定義位置的不同，實際內(nèi)存的開辟位置存在一定的區(qū)別，主要有兩類：

局部變量：內(nèi)存開辟在棧中；
靜態(tài)變量（static 修飾的變量）或全局變量：內(nèi)存開辟在全局靜態(tài)存儲區(qū)。

兩種變量主要是生命周期的不同：局部變量在退出當前作用域后（比如函數(shù)返回），內(nèi)存自動釋放；靜態(tài)變量或全局變量內(nèi)存開辟在全局靜態(tài)存儲區(qū)，它們在程序的整個生命周期均有效。

內(nèi)存可以有 3 種來源，它們的優(yōu)缺點對比詳見下表：

不同來源的內(nèi)存各有優(yōu)劣。前面提到，stack_create()函數(shù)將內(nèi)存的來源限制為僅動態(tài)內(nèi)存不太合理。為了避免內(nèi)存來源受限，“內(nèi)存的分配”這一步交由用戶實現(xiàn)，以便用戶根據(jù)實際需要自由選擇內(nèi)存的來源?；诖?，可以將對象的創(chuàng)建拆分為兩個獨立的步驟，分配對象所需的內(nèi)存和初始化對象。

2.2.3 分配對象所需的內(nèi)存

內(nèi)存分配的工作交由用戶完成，以便用戶根據(jù)實際需要自由選擇。用戶能夠完成內(nèi)存分配的前提是：用戶知道應該分配的內(nèi)存大小。前面提到，每個棧對象需要兩部分內(nèi)存：一是棧對象本身的內(nèi)存（內(nèi)存大小為：sizeof(struct stack)）；二是該棧對象用于存儲數(shù)據(jù)的緩存（內(nèi)存大小為 sizeof(int) * size，其中，size 由用戶在創(chuàng)建棧時通過參數(shù)指定）。

1、棧對象本身的內(nèi)存

棧對象本身的內(nèi)存大小為 sizeof(struct stack)，若用戶直接采用靜態(tài)內(nèi)存分配的方式（直接定義一個變量），則形式如下：

structstackmy_stack;

也可以繼續(xù)采用動態(tài)內(nèi)存的分配方式，例如：

structstack*p_stack=(structstack*)malloc(sizeof(structstack));

但是，若將這兩行代碼直接放到主程序中會無法編譯，因為之前描述的“封裝”特性，使外界看不到 struct stack 的具體定義，也就是說，對于外界而言，該類型僅僅只是聲明并未定義，該類型對應變量的大小對外也是未知的。

在 C 語言中定義一個變量時，編譯器將負責該變量所占用內(nèi)存的分配。內(nèi)存的大小與類型相關，要完成變量內(nèi)存的分配，編譯器必須知道變量所占用的存儲空間大小。當一個變量的類型未定義時，無法完成該類型對應變量的定義，因此，如下語句在編譯時會出錯：

structstackmy_stack;

同理，sizeof 語句用于獲得相應類型數(shù)據(jù)的大小，而未定義的類型顯然是不知道其大小的，動態(tài)內(nèi)存分配中所使用的 sizeof(struct stack)語句也是錯誤的。

也許部分人會有疑問，既然該類型未定義，為什么在主程序中定義該類型的指針變量卻可以呢？

structstack*p_stack=//...

雖然 struct stack 類型未定義，但在之前已經(jīng)聲明，因此，編譯器知道它是一個“合法的結(jié)構(gòu)體類型”。此外，這里定義的是一個指針變量，在特定系統(tǒng)中，指針變量所占用的內(nèi)存大小是確定的，例如，在 32 位系統(tǒng)中，指針通常占用 4 個字節(jié)。即指針變量所占用的內(nèi)存空間大小與其指向的數(shù)據(jù)類型無關，編譯器無需知道其指向的數(shù)據(jù)類型，就可完成指針變量內(nèi)存的分配。因此，一個類型未定義，只要其聲明了，就可以定義該類型的指針變量。但需要注意的是，在完成該類型的定義之前，不得嘗試訪問該指針所指向的內(nèi)容。

完成內(nèi)存的分配，提供三種方案。

（1） 將類的具體定義放到 H 文件中

為了使用戶知道對象內(nèi)存的大小，一種最簡單的辦法是直接將類型的定義放在 H 文件中。更新后的 H 文件示意代碼如下：

stack.h文件

#ifndef__STACK_H
#define__STACK_H

/*類型定義*/
structstack
{
inttop;/*棧頂*/
int*p_buf;/*棧緩存*/
unsignedintsize;/*棧緩存的大小*/
};

//......其它函數(shù)聲明
#endif

此時，對于外界，類型已經(jīng)定義，如下語句均可正常使用：

structstackmy_stack;//靜態(tài)內(nèi)存分配
structstack*p_stack=(structstack*)malloc(sizeof(structstack));//動態(tài)內(nèi)存分配

由于類型的定義存放到了 H 文件中，暴露了類中的成員，在一定程度上破壞了類的“封裝”性。此時外界可以直接訪問類中的數(shù)據(jù)成員。犧牲一定的封裝性，換來內(nèi)存分配的靈活性，這也是在嵌入式系統(tǒng)中，基于 C 語言實現(xiàn)面向?qū)ο缶幊痰囊话阕龇ǎ〝?shù)據(jù)結(jié)構(gòu)定義存放在 H 文件中更加符合程序員的編程風格）。嵌入式軟件大多數(shù)類定義在 H文件中，并沒有封裝在 C 文件中。

雖然類的定義存放在 H 文件中，但出于封裝性考慮，外界任何時候都不應直接訪問對象中的數(shù)據(jù)，應該將其視為使用 C 語言實現(xiàn)面向?qū)ο缶幊痰囊粭l準則。軟件開發(fā)需要遵守兩個規(guī)則：一是在設計類時，應考慮到用戶可能訪問的數(shù)據(jù)，并為這些數(shù)據(jù)提供相應的訪問接口；二是在使用別人提供的類時，除非有特殊說明，否則都不應該嘗試直接訪問類中的數(shù)據(jù)。

這種方法是目前嵌入式系統(tǒng)中使用得最為廣泛的一種方法，因此后文使用這種方法討論。

（2） 在 H 文件中定義一個新的結(jié)構(gòu)體類型

為了繼續(xù)保持類的封裝性，類的定義依然保留在 C 文件中。只不過與此同時，在 H 文件中定義一個新的結(jié)構(gòu)體類型。在該結(jié)構(gòu)體類型中，各個成員的順序和類型與類定義完全一致，僅命名不同。

structstack_mem
{
intdummy1;
int*dummy2;
unsignedintdummy3;
};

各成員的順序和類型均與 struct stack 的定義完全相同，以此保證兩個類型數(shù)據(jù)所需要的內(nèi)存空間完全一致。同時，為了屏蔽各個成員的具體含義，所有成員均以 dummy 開頭進行命名。對于外界來講，可以基于 struct stack_mem 類型完成內(nèi)存的分配，例如：

structstack_memmy_stack;//靜態(tài)內(nèi)存分配
structstack*p_stack=(structstack*)malloc(sizeof(structstack_mem));//動態(tài)內(nèi)存分配

使用這種方案，類的實際定義依然沒有暴露給外界，繼續(xù)保持了良好的封裝。（微信公眾號【嵌入式系統(tǒng)】實際上FreeRTOS中，很多地方都采用了這種方法）。但這里定義了一個新的類型，給用戶理解上造成了一定的困擾，此外，為確保兩個類型完全一致，就要求類的設計者在修改類的定義時，必須確保 struct stack_mem 類型也同步修改，這給類的維護工作帶來了挑戰(zhàn)；稍有不慎，某一個類型沒有同步修改就可能造成嚴重的錯誤，且這種錯誤編譯器不會給出任何提示，非常隱蔽。關于代碼審查可以參考《代碼審查那些事》、《代碼的保養(yǎng)》。

（3） 使用宏的形式告知對象所需的內(nèi)存大小

既然外界只需要知道對象內(nèi)存的大小，可以在開發(fā)過程中使用 sizoeof()獲得struct stack 類型的大小，然后將其以宏的形式定義在 H 文件中。例如在 32 位系統(tǒng)中，使用 sizeof()獲知 struct stack 類型的長度為 12，則可以在 H 文件中定義一個宏，例如：

#defineSTACK_MEM_SIZE12

用戶使用該宏完成內(nèi)存分配，例如：

unsignedcharstack_mem[STACK_MEM_SIZE];

這種做法僅僅在頭文件中新增了一個宏定義，類的定義依然保持的 C 文件中，“封裝”完全沒有被破壞，看起來也非常完美。但這種做法也存在一些問題，因而很少采用。

a)對于同一個類型，不同系統(tǒng)中 sizeof()的結(jié)果可能不同。類型的長度與系統(tǒng)和編譯器均相關。以 int 類型為例，在 32 位系統(tǒng)中為 32 位（4 字節(jié)），但 16 位系統(tǒng)中，其位寬可能為 16 位（2 字節(jié)）。因此，同樣是 sizeof(int)，結(jié)果可能為 4，也可能為 2。使用 sizeof()獲取類型的長度時，不同系統(tǒng)中獲取的結(jié)果可能并不相同。這就導致 H 文件中的宏定義，切換平臺需要重新測試驗證。同時，由于類型的定義封裝到了 C 文件中，因此修改過程只能有類的開發(fā)者完成，一般用戶還無法完成，這就使得該類的跨平臺特性很差，移植有風險。

b)內(nèi)存不僅有大小的要求，還有內(nèi)存對齊的要求。

因此，通過一個宏告知用戶需要分配的內(nèi)存空間大小并不是十分合適，會遇到跨平臺、內(nèi)存對齊等多個注意事項，用戶可能在不經(jīng)意間出錯。在實際嵌入式系統(tǒng)中很少使用。一些編碼技能可以參考《高質(zhì)量嵌入式軟件的開發(fā)技巧》。

2、存儲數(shù)據(jù)的緩存

存儲數(shù)據(jù)的緩存大小為 sizeof(int) *size，其中的 size 本身就是由用戶指定的，這部分內(nèi)存的大小用戶很容易得知，進而完成內(nèi)存的分配?？梢圆捎渺o態(tài)內(nèi)存分配的方式（直接定義一個變量）完成內(nèi)存的分配：

intbuf[20];

也可以采用動態(tài)內(nèi)存分配的方式完成內(nèi)存的分配：

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

2.2.4 內(nèi)存小曲

內(nèi)存的來源主要有三種：動態(tài)內(nèi)存、靜態(tài)內(nèi)存和棧內(nèi)存，具體如何選擇按實際情況。

一些入式應用對確定性要求較高，建議優(yōu)先使用靜態(tài)對象。如此一來只要能夠編譯（包含鏈接）成功，應用程序往往就可以按照確定的流程正確執(zhí)行；若使用動態(tài)對象，則必須考慮對象創(chuàng)建失敗的情況。偶爾使用的大塊內(nèi)存則建議使用動態(tài)內(nèi)存，使用注意和防范可參考《動態(tài)內(nèi)存管理及防御性編程》。

2.3 初始化對象

初始化對象的具體細節(jié)用戶不需要關心，指定棧對象的地址、緩存地址及緩存大小，基于此，可以定義初始化函數(shù)的原型為：

intstack_init(structstack*p_stack,int*p_buf,intsize);

對于棧來講，棧頂索引（top）的初始值恒為 0，因此該值無需通過初始化函數(shù)的參數(shù)傳遞。int 類型的返回值常用于表示執(zhí)行的結(jié)果（微信公眾號【嵌入式系統(tǒng)】建議非指針類型的返回值，以0表示成功，負數(shù)表示失?。?。該函數(shù)的實現(xiàn)示意如下：

//微信公眾號：嵌入式系統(tǒng)
intstack_init(structstack*p_stack,int*p_buf,intsize)
{
p_stack->top=0;
p_stack->size=size;
p_stack->p_buf=p_buf;
return0;
}

該初始化函數(shù)的實現(xiàn)僅作為原理性展示，沒有做過多的錯誤處理或參數(shù)檢查，實際應用中，p_stack 為 NULL 或 p_buf 為 NULL 等情況都是錯誤情況，后續(xù)范例也會省去部分參數(shù)校驗）。

至此，完成了將創(chuàng)建對象分離為“分配對象所需的內(nèi)存”和“初始化對象”兩個步驟，對象內(nèi)存的來源交由用戶決定，用戶根據(jù)需要獲得內(nèi)存后，再將相關內(nèi)存的首地址傳遞給初始化函數(shù)。

2.4 銷毀對象

實現(xiàn) stack_create()以及對應的stack_delete()，設計該函數(shù)的初衷是當一個棧對象不會再被使用時，可以通過該函數(shù)釋放棧占用的資源，比如釋放在 stack_create()函數(shù)中使用 malloc()分配的內(nèi)存資源。

當將 stack_create()拆分為兩步后，內(nèi)存的分配將由用戶決定，對應地內(nèi)存的釋放也應由用戶決定?；仡?stack_delete()函數(shù)的實現(xiàn)，該函數(shù)目前只做了內(nèi)存釋放相關的操作，當不需要釋放內(nèi)存時，該函數(shù)看起來沒有存在的必要。實際上，stack_delete()和 stack_create()函數(shù)是對應的，當將 stack_create()拆分為“分配對象所需的內(nèi)存”和“初始化對象”兩個步驟后，stack_delete()也應該相應的拆分為兩個步驟：“釋放對象占用的內(nèi)存”和“解初始化對象”（微信公眾號【嵌入式系統(tǒng)】解初始化或者反初始化，不用太在意這個操作的名稱，只要理解表達的意思是初始化的逆過程即可，init：deinit，關于命名的英文集客參考《嵌入式軟件命名常用英文集》）。

1． 釋放對象占用的內(nèi)存

前面已經(jīng)提到，釋放內(nèi)存交由用戶處理，釋放方法與內(nèi)存的來源相關。

動態(tài)內(nèi)存的釋放動態(tài)內(nèi)存分配應使用相應的釋放內(nèi)存函數(shù)（如 free()）進行釋放。在釋放時應確保分配的內(nèi)存全部被有效釋放。若某一部分內(nèi)存被遺漏，將造成內(nèi)存泄漏。隨著程序的長期運行，內(nèi)存不斷泄漏可能導致系統(tǒng)崩潰。

靜態(tài)內(nèi)存的釋放使用靜態(tài)內(nèi)存（定義變量的形式），則內(nèi)存的釋放是系統(tǒng)自動完成的。若將對象定義為局部變量，內(nèi)存開辟在系統(tǒng)棧中，則退出當前作用域后（函數(shù)返回）自動釋放；若將對象定義為靜態(tài)變量（static）或全局變量，則內(nèi)存開辟在全局靜態(tài)區(qū)，該區(qū)域的內(nèi)存在應用程序的整個生命周期均有效，無法釋放。

2． 解初始化對象

釋放內(nèi)存已交由用戶處理，對于類的設計來講，重點是設計“解初始化對象”對應的函數(shù)，該函數(shù)與 stack_init()函數(shù)對應，通常命名為“*_deinit”，即：stack_deinit()。該函數(shù)通常用于釋放在初始化對象時占用的其它資源。

對于純軟件對象（與硬件無關的軟件），通常其只會占用內(nèi)存資源，不會額外占用其它資源，對這類對象解初始化時可能無需做任何事情。例如前面關于棧的實現(xiàn)，在stack_init()函數(shù)中僅對幾個屬性進行了賦值，沒有額外占用其它任何資源，此時，stack_deinit()可能無需做任何事情，成為一個空函數(shù)。

intstack_deinit(structstack*p_stack)
{
return0;
}

在嵌入式系統(tǒng)中，經(jīng)常會遇到與硬件相關的對象，其初始化時往往會占用一定的硬件資源：I/O 引腳、系統(tǒng)中斷、系統(tǒng)總線。在解初始化這種對象時，應同時釋放占用的資源。可重點關注對象的初始化函數(shù)，查看其中是否分配、占用了某些資源。若有，則在解初始化函數(shù)中作相應的釋放操作；若無，則解初始化函數(shù)留空。為了提高軟件的簡潔性，也可刪除了空的解初始化函數(shù)，但這里為了展示軟件結(jié)構(gòu)，依然保留了解初始化函數(shù)。

將原 H 文件中的創(chuàng)建接口更新為初始化接口，刪除接口更新為解初始化接口，更新后的 H 文件內(nèi)容和 C 文件如下：

stack.h文件

//微信公眾號：嵌入式系統(tǒng)
#ifndef__STACK_H
#define__STACK_H

/*類型定義*/
structstack
{
inttop;/*棧頂*/
int*p_buf;/*棧緩存*/
unsignedintsize;/*棧緩存的大小*/
};

/*初始化*/
intstack_init(structstack*p_stack,int*p_buf,intsize);

/*入棧*/
intstack_push(structstack*p_stack,intval);

/*出棧*/
intstack_pop(structstack*p_stack,int*p_val);

/*解初始化*/
intstack_deinit(structstack*p_stack);

#endif

stack.c文件

//微信公眾號：嵌入式系統(tǒng)
#include"stack.h"

intstack_init(structstack*p_stack,int*p_buf,intsize)
{
p_stack->top=0;
p_stack->size=size;
p_stack->p_buf=p_buf;
return0;
}

intstack_push(structstack*p_stack,intval)
{
if(p_stack->top!=p_stack->size)
{
p_stack->p_buf[p_stack->top++]=val;
return0;
}
return-1;
}

intstack_pop(structstack*p_stack,int*p_val)
{
if(p_stack->top!=0)
{
*p_val=p_stack->p_buf[--p_stack->top];
return0;
}
return-1;
}

intstack_deinit(structstack*p_stack)
{
return0;
}

3． 銷毀對象的順序

創(chuàng)建對象時是先分配對象所需內(nèi)存，再初始化對象，因為在初始化對象時，需要傳遞相應內(nèi)存空間的首地址作為初始化函數(shù)的參數(shù)。這就保證了在初始化對象之前，必須完成相關內(nèi)存的分配。而銷毀一個對象時，釋放內(nèi)存與調(diào)用解初始化函數(shù)并不能通過接口進行制約，銷毀過程與創(chuàng)建恰恰相反，應先解初始化對象，再釋放對象占用的內(nèi)存。因為在解初始化對象時，還會使用到對象中的數(shù)據(jù)，若先釋放對象占用的內(nèi)存，則對象在被解初始化之前，就被徹底銷毀了，對象已經(jīng)不存在了，顯然無法再進行解初始化操作。

若內(nèi)存來源于動態(tài)內(nèi)存分配，則完整的應用程序范例如下：

//微信公眾號：嵌入式系統(tǒng)
#include"stack.h"
#include"stdio.h"
#include"stdlib.h"
intmain()
{
intval;
structstack*p_stack=(structstack*)malloc(sizeof(structstack));
int*p_buf=(int*)malloc(sizeof(int)*20);

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

//依次壓入數(shù)據(jù)：2、4、5、8
stack_push(p_stack,2);
stack_push(p_stack,4);
stack_push(p_stack,5);
stack_push(p_stack,8);

//依次彈出各個數(shù)據(jù)，并打印
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);

//釋放內(nèi)存
free(p_stack);
free(p_buf);

return0;
}

若內(nèi)存來源于靜態(tài)內(nèi)存分配，則內(nèi)存的分配和釋放完全由系統(tǒng)自行完成，如內(nèi)存以“局部變量”的形式分配，范例程序如下：

//微信公眾號：嵌入式系統(tǒng)
#include"stack.h"
#include"stdio.h"
intmain()
{
intval;
intbuf[20];
structstackstack;
structstack*p_stack=&stack;

stack_init(p_stack,buf,20);

//依次壓入數(shù)據(jù)：2、4、5、8
stack_push(p_stack,2);
stack_push(p_stack,4);
stack_push(p_stack,5);
stack_push(p_stack,8);

//依次彈出各個數(shù)據(jù)，并打印
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);
return0;
}

從形式上看，雖然棧類的代碼變得復雜了一些，但對象內(nèi)存的來源更具有靈活性，使得棧的適用范圍更加廣泛。在部分系統(tǒng)中，在保證對象內(nèi)存來源不受限制的同時，為了特殊情況下的便利性，往往還保留了基于動態(tài)內(nèi)存分配創(chuàng)建對象的方法，在這種情況下，將同時提供create 和 init 兩套接口。

以 FreeRTOS 為例，其提供了兩套創(chuàng)建任務的接口：xTaskCreate()和 xTaskCreateStatic()。其中，xTaskCreate()函數(shù)中采用動態(tài)內(nèi)存分配的方法獲得了任務相關內(nèi)存；而 xTaskCreateStatic()函數(shù)即用于以“靜態(tài)”的方式創(chuàng)建任務，任務相關的內(nèi)存需要用戶通過函數(shù)的參數(shù)傳遞（實際上該函數(shù)的作用就類似于 init 初始化函數(shù)，只不過其命名為了 Create）。freeRTOS可以作為RTOS開發(fā)入門的基礎，具體可參考《FreeRTOS及其應用，萬字長文，基礎入門》、《基于RTOS的軟件開發(fā)理論》。

在絕大部分面向?qū)ο缶幊陶Z言中，也有類似于初始化和解初始化的接口，以C++為例，在定義類時，每個類都有構(gòu)造函數(shù)和析構(gòu)函數(shù)兩個特殊的函數(shù)。構(gòu)造函數(shù)就相當于這里的初始化函數(shù)，其在創(chuàng)建對象時自動調(diào)用；析構(gòu)函數(shù)就相當于這里的解初始化函數(shù)，其在銷毀對象時自動調(diào)用。例如，以局部變量的形式定義一個對象，則在定義對象時，會自動調(diào)用構(gòu)造函數(shù)；在退出當前作用域（函數(shù)返回）時，會自動調(diào)用析構(gòu)函數(shù)。高級的面向?qū)ο缶幊陶Z言，為很多操作提供了語法特性上的原生支持，給實際編程帶來了極大的便利。

3 繼承

繼承表示了一種類與類之間的特殊關系，即 is-a 關系，例如蘋果是一種水果。A is-a B，表明了 A 只是 B 的一個特例，并不是 B 的全部，A（蘋果）是子類，B（水果）是父類（又稱基類、超類）。

子類是父類的一個特例，可以看作是在父類的基礎上作了一些屬性或方法的擴展，子類依然具有父類的屬性和方法。使用繼承關系在一個已經(jīng)存在的類的基礎上，定義一個新類。新類將自動繼承已存在類的屬性和方法，并可根據(jù)需要添加新的屬性和方法。繼承使子類可以重用父類中已經(jīng)實現(xiàn)的屬性和方法，無需再重復設計和編程，以此實現(xiàn)代碼最大限度的復用。

3.1 “繼承”示例

在 C 語言編程中，在定義子類（子類結(jié)構(gòu)體類型）時，通過將父類作為子類的第一個成員實現(xiàn)繼承。之所以這樣做，是因為在 C 語言結(jié)構(gòu)體中，第一個成員（父類）的地址和結(jié)構(gòu)體自身（子類）的地址相同，當子類需要復用父類的方法時，子類的地址也可以作為父類的地址使用（微信公眾號【嵌入式系統(tǒng)】這是后續(xù)繼承操作取巧的基礎）。

例如在一個系統(tǒng)中具有多個棧，為便于區(qū)分，每個?？梢跃哂胁煌拿Q（系統(tǒng)棧、數(shù)據(jù)棧、符號棧……）?；谠撔枨?，可以實現(xiàn)一個帶名稱的棧（為便于和前文普通棧區(qū)分，后文將其稱為“命名?！保丛谄胀５幕A上，增加一個“名稱”屬性，該屬性使每個棧都具有一個可供識別的名稱，該棧類型的定義及接口聲明如下：

stack_named.h文件

//微信公眾號：嵌入式系統(tǒng)
#ifndef__STACK_NAMED_H
#define__STACK_NAMED_H

#include"stack.h"/*包含基類頭文件*/

structstack_named
{
structstacksuper;/*基類（超類）*/
constchar*p_name;/*棧名*/
};

/*初始化*/
intstack_named_init(structstack_named*p_stack,int*p_buf,intsize,constchar*p_name);

/*設置名稱*/
intstack_named_set(structstack_named*p_stack,constchar*p_name);

/*獲取名稱*/
constchar*stack_named_get(structstack_named*p_stack);

/*解初始化*/
intstack_named_deinit(structstack_named*p_stack);

#endif

stack_named.c文件

//微信公眾號：嵌入式系統(tǒng)
#include"stack_named.h"

intstack_named_init(structstack_named*p_stack,int*p_buf,intsize,constchar*p_name)
{
stack_init(&p_stack->super,p_buf,size);/*初始化基類*/
p_stack->p_name=p_name;/*初始化子類成員*/
return0;
}

intstack_named_set(structstack_named*p_stack,constchar*p_name)
{
p_stack->p_name=p_name;
return0;
}

constchar*stack_named_get(structstack_named*p_stack)
{
returnp_stack->p_name;
}

intstack_named_deinit(structstack_named*p_stack)
{
returnstack_deinit(&p_stack->super);/*解初始化基類*/
}

實現(xiàn)“命名?！睍r，除初始化函數(shù)和解初始化函數(shù)外，僅為新增的屬性p_name 提供了設置和獲取方法，棧的核心邏輯相關函數(shù)（入棧、出棧）無需重復實現(xiàn)，入棧和出棧方法作為“命名棧”父類的方法，可以被復用。使用“命名?！钡膽贸绦蚍独缦拢?/p>

//微信公眾號：嵌入式系統(tǒng)
#include"stack_named.h"
#include"stdio.h"
intmain()
{
intval;
intbuf[20];
structstack_namedstack_named;
structstack_named*p_stack_named=&stack_named;

stack_named_init(p_stack_named,buf,20,"chengj");
printf("Thestacknameis%s!
",stack_named_get(p_stack_named));

//依次壓入數(shù)據(jù)：2、4、5、8
stack_push((structstack*)p_stack_named,2);//強制棧類型轉(zhuǎn)換
stack_push((structstack*)p_stack_named,4);
stack_push((structstack*)p_stack_named,5);
stack_push((structstack*)p_stack_named,8);

//依次彈出各個數(shù)據(jù)，并打印
stack_pop((structstack*)p_stack_named,&val);//強制棧類型轉(zhuǎn)換
printf("%d",val);
stack_pop((structstack*)p_stack_named,&val);
printf("%d",val);
stack_pop((structstack*)p_stack_named,&val);
printf("%d",val);
stack_pop((structstack*)p_stack_named,&val);
printf("%d",val);

stack_named_deinit(p_stack_named);
return0;
}

程序中，因為父類（struct stack）和子類（struct stack_named）對應的類型并不相同，所以當父類方法（stack_push()、stack_pop()）作用于子類對象（stack_named）時，為了避免編譯器輸出“類型不匹配”的警告，必須對類型進行強制轉(zhuǎn)換。

在 C 語言中，大量的使用類型強制轉(zhuǎn)換存在一定的風險，如兩個類之間沒有繼承關系，使用強制轉(zhuǎn)換將屏蔽編譯器輸出的警告信息，導致這類錯誤在編譯階段無法發(fā)現(xiàn)。為了避免使用強制類型轉(zhuǎn)換，可以多做一步操作，從子類中取出父類的地址進行傳遞，保證參數(shù)類型一致：

stack_push((structstack*)p_stack_named,2);
//改為
stack_push(&p_stack_named->super,2);

但無論使用哪種方法，看起來都不是很完美。這類問題的存在主要是因為 C語言并非真正的面向?qū)ο缶幊陶Z言，使用 C 語言實現(xiàn)面向?qū)ο缶幊虝r，需要使用到一些看似“投機取巧”的手段。在真正的面向?qū)ο缶幊陶Z言中，編譯器可以識別繼承關系，無需任何強制轉(zhuǎn)換語句，父類的方法可以直接作用于子類。

3.2 初始化函數(shù)

回顧前面命名棧初始化函數(shù)：

intstack_named_init(structstack_named*p_stack,int*p_buf,intsize,constchar*p_name)
{
stack_init(&p_stack->super,p_buf,size);/*初始化基類*/
p_stack->p_name=p_name;/*初始化子類成員*/
return0;
}

先調(diào)用了父類的初始化函數(shù)（stack_init()），再初始化命名棧特有的 p_name 屬性。這里指出了一個隱含的規(guī)則：先初始化基類的成員，再初始化派生類特有的成員。該規(guī)則與面向?qū)ο缶幊陶Z言中構(gòu)造函數(shù)的調(diào)用順序是一致的：在建立一個對象時，首先調(diào)用基類的構(gòu)造函數(shù)，然后再調(diào)用派生類的構(gòu)造函數(shù)。

3.3 解初始化函數(shù)

解初始化的順序與初始化的順序是恰好相反的，應先對派生類中特有的數(shù)據(jù)“解初始化”，再對基類作解初始化操作。解初始化函數(shù)的實現(xiàn)詳見程序如下：

intstack_deinit(structstack*p_stack)
{
p_stack->top=0;
return0;
}

intstack_named_deinit(structstack_named*p_stack)
{
p_stack->p_name=NULL;
returnstack_deinit(&p_stack->super);/*解初始化基類在后*/
}

3.4 最少知識原則

所謂 “最少知識原則”就是，對使用者而言，不管類的內(nèi)部如何，只調(diào)用提供的方法，其他的一概不管。（微信公眾號【嵌入式系統(tǒng)】更多編碼原則可以參考《嵌入式軟件設計原則隨想》）顯然前面的“命名?！辈⒎侨绱?，對于命名棧的使用者，其必須知道命名棧與普通棧之間的繼承關系，進而才可以正確的使用普通棧的入棧方法，操作命名棧，例如：

stack_push((structstack*)p_stack_named,2);//類型轉(zhuǎn)換關系

這對用戶來說并不友好，因為其使用的是“命名棧”類（stack_named.h），卻還要關心“普通?！鳖悾╯tack.h）。為滿足“最少知識原則”，命名棧也可以提供入棧和出棧方法，使用戶僅需關心命名棧的公共接口就可以完成命名棧的所有操作。

stack_named.h文件

#ifndef__STACK_NAMED_H
#define__STACK_NAMED_H

#include"stack.h"

/*包含基類頭文件*/

structstack_named
{
structstacksuper;/*基類（超類）*/
constchar*p_name;/*棧名*/
};

/*初始化*/
intstack_named_init(structstack_named*p_stack,int*p_buf,intsize,constchar*p_name);

/*設置名稱*/
intstack_named_set(structstack_named*p_stack,constchar*p_name);

/*獲取名稱*/
constchar*stack_named_get(structstack_named*p_stack);

//微信公眾號：嵌入式系統(tǒng)
staticinlineintstack_named_push(structstack_named*p_stack,intval)
{
returnstack_push(&p_stack->super,val);
}
staticinlineintstack_named_pop(structstack_named*p_stack,int*p_val)
{
returnstack_pop(&p_stack->super,p_val);
}

/*解初始化*/
intstack_named_deinit(structstack_named*p_stack);

#endif

頭文件中增加了兩個方法：stack_named_push()和 stack_named_pop()，由于這兩個函數(shù)非常簡單，只是調(diào)用了其父類中相應的方法，僅一行代碼，因而使用了內(nèi)聯(lián)函數(shù)的形式，如此可以優(yōu)化代碼大小和執(zhí)行速度。經(jīng)過簡單的包裝后，用戶使用的所有方法都是作用于“命名棧”對象的，無需再使用類型強制轉(zhuǎn)換等特殊的方法。更新后的“命名?！笔褂梅独稳缦拢?/p>

//壓入數(shù)據(jù)
stack_named_push(p_stack_named,2);

//彈出數(shù)據(jù)并打印
stack_named_pop(p_stack_named,&val);printf("%d",val);

從用戶角度看，包裝后的“命名?！睂τ脩魜碇v更加友好（無需類型強制轉(zhuǎn)換）。但在實際開發(fā)過程中，若所有繼承關系都再次封裝一遍會顯得累贅。因此，只對用戶開放的類才需要這樣做，如果某些類無需對用戶開放，僅在內(nèi)部使用，則可以酌情省略包裝過程。

4 多態(tài)

多態(tài)字面含義就是具有“多種形式”。從調(diào)用者的角度看對象，會發(fā)現(xiàn)它們非常相似，但內(nèi)部處理實際上卻各不相同。換句話說，各對象雖然內(nèi)部處理不同，但對于使用者（調(diào)用者）來講，它們卻是相同的。

4.1 學生的“自我介紹”

在前面提到的學生類，包含姓名、學號、性別、身高、體重等屬性，并對外提供了一個“自我介紹”方法。

voidstudent_self_introduction(structstudent*p_this)
{
printf("Hi!Mynameis%s,I'ma%s.Myschoolnumberis%d.Myheightis%fcmandweightis%fkg",
p_this->name,
(p_this->sex=='M')?"boy":"girl",
p_this->id,
p_this->height,
p_this->weight);
}

假設一個場景，開學第一課所有同學依次作一個簡單的自我介紹，調(diào)用所有同學的自我介紹方法即可，范例程序如下：

voidfirst_class(structstudent*p_students,intnum)
{
inti;
for(i=0;i

	

	

	調(diào)用該函數(shù)前，需要將所有學生對象創(chuàng)建好，并存于一個數(shù)組中，假定一個班級有 50個學生，則調(diào)用示意代碼如下：

	

	
intmain()
{
structstudentstudent[50];

/*根據(jù)每個學生的信息，依次創(chuàng)建各個學生對象*/
student_init(&student[0],"zhangsan",2024001,'M',173,60);
student_init(&student[1],"lisi",2024002,'F',168,65);
//...

/*上第一節(jié)課*/
first_class(student,50);
}


	

	

	上面的實現(xiàn)代碼，假定了學生的“自我介紹”格式是完全相同的，都是將個人信息陳述一遍，顯然，這樣的自我介紹無法體現(xiàn)每個學生的個性和差異。例如，一個名叫張三的學生，其期望這樣介紹自己：

	“親愛的老師，同學們！我叫張三，來自湖北仙桃，是一個自信開朗，積極向上的人，我有著廣泛的興趣愛好，喜歡打籃球、看書、下棋、聽音樂……”

	每個學生自我介紹的內(nèi)容并不期望千篇一律。若不基于多態(tài)的思想，最簡單粗暴的方式是每個學生都提供一個自我介紹方法，例如 student_zhangsan_introduction()。這種情況下每個學生提供的方法都不相同（函數(shù)名不同），根本無法統(tǒng)一調(diào)用，此時，第一節(jié)課的調(diào)用將會大改，需要依次調(diào)用每個學生提供的不同的自我介紹方法，例如：

	

	
voidfirst_class()
{
student_zhangsan_introduction(&zhangshan);//張三自我介紹
student_lisi_introduction(&lisi);//李四自我介紹
//….
}


	

	

	無法使用同樣的調(diào)用形式（函數(shù)）完成不同對象的“自我介紹”。對于調(diào)用者來講，需要關注每個對象提供的特殊方法，復雜度將提升。

	使用多態(tài)的思想即可很好的解決這個問題，進而保證 firstt_class()的內(nèi)容不變，雖然每個對象方法的實現(xiàn)不同，但可以使用同樣的形式調(diào)用它。在 C 語言中，函數(shù)指針就是解決這個問題的“利器”。

	函數(shù)指針的原型決定了調(diào)用方法，例如定義函數(shù)指針：

	

	
int(*student_self_introduction)(structstudent*p_student);


	

	

	無論該函數(shù)指針指向何處，都表示該函數(shù)指針指向的是 int 類型返回值，具有一個*p_student 參數(shù)的函數(shù)，其調(diào)用形式如下：

	

	
student_self_introduction(p_student);


	

	

	函數(shù)指針的指向代表了函數(shù)的實現(xiàn)，指向不同的函數(shù)就代表了不同的實現(xiàn)?；诖耍瑸榱耸姑總€學生對象可以有自己獨特的介紹方式，在學生類的定義中，可以不實現(xiàn)自我介紹方法，但可以通過函數(shù)指針約定自我介紹方法的調(diào)用形式。更新學生類的定義：

	

	
student.h文件```

```c
//微信公眾號：嵌入式系統(tǒng)
#ifndef__STUDENT_H
#define__STUDENT_H

structstudent
{
int(*student_self_introduction)(structstudent*p_student);/*新增個性化自我介紹*/
charname[10];/*姓名（假定最長10字符）*/
unsignedintid;/*學號*/
charsex;/*性別:'M'，男；'F'，女*/
floatheight;/*身高*/
floatweight;/*體重*/
};

intstudent_init(structstudent*p_student,
char*p_name,
unsignedintid,
charsex,
floatheight,
floatweight,
int(*student_self_introduction)(structstudent*));

/*學生類提供的自我介紹方法*/
staticinlineintstudent_self_introduction(structstudent*p_student)
{
returnp_student->student_self_introduction(p_student);
}

#endif


	

	

	此時，對于外界來講，學生類“自我介紹方法”的調(diào)用形式并未發(fā)生任何改變，函數(shù)原型還是一樣的（由于只有一行代碼，因而以內(nèi)聯(lián)函數(shù)的形式存放到了頭文件中）?；诖?，“第一節(jié)課的內(nèi)容”可以保持完全不變（for循環(huán)調(diào)用全部）。在這種方式下，每個對象在初始化時，需要指定自己特殊的自我介紹方，例如張三對象的創(chuàng)建過程為：

	

	
intstudent_zhangsan_introduction(structstudent*p_student)
{
constchar*str="親愛的老師，同學們！我叫張三，來自湖北仙桃，是一個自信開朗，積極向上的人，我有著廣泛的興趣愛好，喜歡打籃球、看書、下棋、聽音樂……";

printf("%s
",str);
return0;
}

intmain()
{
structstudentstudent[50];

/*根據(jù)每個學生的信息，依次創(chuàng)建各個學生對象*/
student_init(&student[0],"zhangsan",2024001,'M',173,60,student_zhangsan_introduction);

//...

/*上第一節(jié)課*/
first_class(student,50);
}


	

	

	多態(tài)的核心是：對于上層調(diào)用者，不同的對象可以使用完全相同的操作方法，但是每個對象可以有各自不同的實現(xiàn)方式。多態(tài)是面向?qū)ο缶幊谭浅Ｖ匾奶匦?，C 語言依賴指針實現(xiàn)多態(tài)。

	很多設計模式或硬件多型號適配都是基于這個基礎，可以參考《嵌入式軟件的設計模式（上）》）。

	4.2 I/O 設備驅(qū)動

	C 程序使用 printf()打印日志信息，在 PC 上運行時，日志信息可能輸出到控制臺，而在嵌入式系統(tǒng)中，信息可能通過某個串口輸出。printf()函數(shù)的解釋是輸出信息至 STDOUT（標準輸出）。顯然printf()函數(shù)就具有多態(tài)性，對于用戶來講，其調(diào)用形式是確定的，但內(nèi)部具體輸出信息到哪里，卻會隨著 STDOUT 的不同而不同。

	在一些操作系統(tǒng)中（如Linux），硬件設備（例串口、ADC 等）的操作方法都和文件操作方法類似（一切皆文件），都可以通過 open()、close()、read()、write()等幾個標準函數(shù)進行操作。為統(tǒng)一 I/O 設備的使用方法，要求每個 I/O 設備都提供 open、close、read、write 這幾個標準函數(shù)的實現(xiàn)，即每個 I/O設備的驅(qū)動程序，對這些標準函數(shù)的實現(xiàn)在函數(shù)調(diào)用上必須保持一致。這本質(zhì)上就是一個多態(tài)問題，即以同樣的方法使用不同的 I/O 設備。

	通過函數(shù)指針解決這個問題，首先定義file_ops結(jié)構(gòu)體，包含了相對應的函數(shù)指針，指向I/O 設備針對操作的實現(xiàn)函數(shù)。

	

	
file_ops.h文件

//微信公眾號：嵌入式系統(tǒng)
//代碼片段只是原理性展示
structfile_ops
{
void(*open)(char*name,intmode);
void(*close)();
int(*read)();
void(*write)();
};


	

	

	對于 I/O設備，其驅(qū)動程序提供這 4個函數(shù)的實現(xiàn)，并將 file_ops結(jié)構(gòu)體的函數(shù)指針指向?qū)暮瘮?shù)。

	

	
#include"file_ops.h"

staticvoidopen(char*name,intmode)
{
//...
}

staticvoidclose()
{
//...
}

staticintread()
{
//...
}

staticvoidwrite()
{
//...
}

structfile_opsmy_console={open,close,read,write};


	

	

	所有的函數(shù)都使用 static修飾符，避免與外部的函數(shù)產(chǎn)生命名沖突。對于該設備，僅對外提供了一個可以使用的 file_ops 對象 my_console。

	上面展示了設備 I/O 的一般管理方法，其中的編程方法或技巧正是面向?qū)ο缶幊讨卸鄳B(tài)的基礎，也再一次展現(xiàn)了函數(shù)指針在多態(tài)中的重要地位，多態(tài)可以視為函數(shù)指針的一種典型應用。（微信公眾號【嵌入式系統(tǒng)】類似使用是Linux設備驅(qū)動的基礎）。

	4.3 帶檢查功能的棧

	前面范例實現(xiàn)了棧的核心邏輯（入棧和出棧），假設現(xiàn)在增加需求，實現(xiàn)“帶檢查功能的?！保丛跀?shù)據(jù)入棧之前，必須進行特定的檢查，“檢查通過”后才能壓人棧中。檢查方式有多種：

	

	
范圍檢查：必須在特定的范圍之內(nèi)，比如1 ~ 9，才視為檢查通過；
奇偶檢查：必須是奇數(shù)或者偶數(shù)，才視為檢查通過；
變化檢查：值必須增加（比上一次的值大），才視為檢查通過。

	

	

	4.3.1 基于繼承實現(xiàn)“帶范圍檢查功能”的棧

	先不考慮多種檢查方式，僅實現(xiàn)范圍檢查。參照“命名?！钡膶崿F(xiàn)，使用繼承方式，在普通棧的基礎上實現(xiàn)一個新類，范例程序如下：

	

	
stack_with_range_check.h帶范圍檢查的棧

#ifndef__STACK_WITH_RANGE_CHECK_H
#define__STACK_WITH_RANGE_CHECK_H

#include"stack.h"/*包含基類頭文件*/

structstack_with_range_check
{
structstacksuper;/*基類（超類）*/
intmin;/*最小值*/
intmax;/*最大值*/
};

intstack_with_range_check_init(structstack_with_range_check*p_stack,
int*p_buf,
intsize,
intmin,intmax);

/*入棧*/
intstack_with_range_check_push(structstack_with_range_check*p_stack,intval);

/*出棧*/
intstack_with_range_check_pop(structstack_with_range_check*p_stack,int*p_val);

#endif


	

	

	帶范圍檢查的棧 C 文件 stack_with_range_check.c

	
#include"stack_with_range_check.h"

intstack_with_range_check_init(structstack_with_range_check*p_stack,
int*p_buf,
intsize,
intmin,intmax)
{
/*初始化基類*/
stack_init(&p_stack->super,p_buf,size);

/*初始化子類成員*/
p_stack->min=min;
p_stack->max=max;
return0;
}

intstack_with_range_check_push(structstack_with_range_check*p_stack,intval)
{
if((val>=p_stack->min)&&(val<=?p_stack->max))//差異點
{
returnstack_push(&p_stack->super,val);
}
return-1;
}

intstack_with_range_check_pop(structstack_with_range_check*p_stack,int*p_val)
{
returnstack_pop(&p_stack->super,p_val);
}


	

	

	為了接口的簡潔性，沒有再展示解初始化等函數(shù)的定義。新增入棧時作檢查，出棧和普通棧是完全相同的，但基于最小知識原則也封裝了一個 pop 接口，使該類的用戶完全不需要關心普通棧。

	依照這個方法，可以實現(xiàn)其它檢查方式的棧。核心是實現(xiàn)帶檢查功能的入棧函數(shù)，因而僅簡單展示另外兩種檢查方式下入棧函數(shù)的實現(xiàn)，分別如下：

	

	
//奇偶檢查入棧函數(shù)
intstack_with_oddeven_check_push(structstack_with_oddeven_check*p_stack,intval)
{
if(((p_stack->iseven)&&((val%2)==0))||((!p_stack->iseven)&&((val%2)!=0)))
{
returnstack_push(&p_stack->super,val);//檢查通過：偶校驗且為偶數(shù)，或奇校驗且為奇數(shù)
}
return-1;
}

//變化檢查入棧函數(shù)
intstack_with_change_check_push(structstack_with_change_check*p_stack,intval)
{
if(p_stack->pre_valuepre_value=val;
returnstack_push(&p_stack->super,val);//檢查通過：本次入棧值大于上一次的值
}
return-1;
}


	

	

	由此可見，這種實現(xiàn)方式存在一定的缺陷，不同檢查方法對應的入棧函數(shù)不相同，對于用戶來講，使用不同的檢查功能，就必須調(diào)用不同的入棧函數(shù)。即操作不同的棧使用不同的接口。但觀察幾個入棧函數(shù)，其入棧方法類似，示意代碼如下：

	

	
intstack_XXX_push(structstack_XXX*p_stack,intval)
{
if(檢查通過)//不同棧的差異僅是檢測條件不同
{
returnstack_push(&p_stack->super,val);
}
return-1;
}


	

	

	可使用多態(tài)思想，將“檢查”函數(shù)的調(diào)用形式標準化編寫一個通用的、與具體檢查方式無關的入棧函數(shù)。

	4.3.2 基于多態(tài)實現(xiàn)通用的“帶檢查功能的?！?/p>

	使用函數(shù)指針表示“檢查功能”，指向不同的檢查函數(shù)。可以定義一個包含函數(shù)指針的類：

	

	
structstack_with_validate
{
structstacksuper;/*基類（超類）*/
int(*validate)(structstack_with_validate*p_this,intval);/*檢查函數(shù)*/
};


	

	

	和其它普通方法一樣，類中抽象方法（函數(shù)指針）的第一個成員同樣是指向該類對象的指針。此時，數(shù)據(jù)入棧前的檢查工作交給 validate 指針所指向的函數(shù)實現(xiàn)。假定其指向的函數(shù)在檢查數(shù)據(jù)時，返回 0 表示檢查通過可入棧，其它值表示檢查未通過。完整的帶檢查功能的棧實現(xiàn)范例如下：

	帶檢查功能的棧 H 文件（stack_with_validate.h）

#ifndef__STACK_WITH_VALIDATE_H
#define__STACK_WITH_VALIDATE_H

#include"stack.h"/*包含基類頭文件*/
structstack_with_validate
{
structstacksuper;/*基類（超類）*/
int(*validate)(structstack_with_validate*p_this,intval);/*檢查函數(shù)*/
};


intstack_with_validate_init(structstack_with_validate*p_stack,
int*p_buf,
intsize,
int(*validate)(structstack_with_validate*,int));

/*入棧*/
intstack_with_validate_push(structstack_with_validate*p_stack,intval);

/*出棧*/
intstack_with_validate_pop(structstack_with_validate*p_stack,int*p_val);

#endif


	

	

	帶檢查功能的棧 C 文件（stack_with_validate.c）

	

	
#include"stack_with_validate.h"
#include"stdio.h"

intstack_with_validate_init(structstack_with_validate*p_stack,
int*p_buf,
intsize,
int(*validate)(structstack_with_validate*,int))

{
/*初始化基類*/
stack_init(&p_stack->super,p_buf,size);
p_stack->validate=validate;//檢查條件，上層說了算
return0;
}

intstack_with_validate_push(structstack_with_validate*p_stack,intval)
{
if((p_stack->validate==NULL)||
((p_stack->validate!=NULL)&&(p_stack->validate(p_stack,val)==0)))
{
returnstack_push(&p_stack->super,val);
}
return-1;
}

intstack_with_validate_pop(structstack_with_validate*p_stack,int*p_val)
{
returnstack_pop(&p_stack->super,p_val);
}


	

	

	帶某種檢查功能的棧，重點是實現(xiàn)其中的 validate 方法?；趲z查的棧，實現(xiàn)帶范圍檢查的棧，程序詳見如下：

	帶范圍檢查的棧 H 文件更新（stack_with_range_check.h）

	

	
#ifndef__STACK_WITH_RANGE_CHECK_H
#define__STACK_WITH_RANGE_CHECK_H

#include"stack_with_validate.h"/*包含基類頭文件*/

structstack_with_range_check
{
structstack_with_validatesuper;/*基類（超類）*/
intmin;/*最小值*/
intmax;/*最大值*/
};

structstack_with_validate*stack_with_range_check_init(structstack_with_range_check*p_stack,
int*p_buf,
intsize,
intmin,
intmax);

#endif


	

	

	帶范圍檢查的棧 C 文件更新（stack_with_range_check.c）

	

	
#include"stack_with_range_check.h"

staticint_validate(structstack_with_validate*p_this,intval)
{
structstack_with_range_check*p_stack=(structstack_with_range_check*)p_this;

if((val>=p_stack->min)&&(val<=?p_stack->max))
{
return0;/*檢查通過*/
}

return-1;
}

structstack_with_validate*stack_with_range_check_init(structstack_with_range_check*p_stack,
int*p_buf,
intsize,
intmin,
intmax)
{
/*初始化基類*/
stack_with_validate_init(&p_stack->super,p_buf,size,_validate);

/*初始化子類成員*/
p_stack->min=min;
p_stack->max=max;
return0;
}


	

	

	帶范圍檢查的棧，主要目的就是實現(xiàn)“檢查功能”對應的函數(shù)：_validate，并將其作為 validate 函數(shù)指針（抽象方法）的值。

	在面向?qū)ο缶幊讨校橄蠓椒ǖ念愅ǔ７Q之為抽象類，抽象類不能直接實例化（因為其還有方法未實現(xiàn)），抽象類只能被繼承，且由子類實現(xiàn)其中定義的抽象方法。在 UML 類圖中，抽象類的類名和其中的抽象方法均使用斜體表示，普通棧、帶檢查功能的棧和帶范圍檢查的棧，它們之間的關系詳見圖。

	

	帶范圍檢查的棧，其主要作用是實現(xiàn)其父類中定義的抽象方法，進而創(chuàng)建一個真正的“帶檢查功能”的棧對象（此時的抽象方法已實現(xiàn)），該對象即可提交給外部使用。帶范圍檢查的棧并沒有其他特殊的方法，因而在其初始化完成后，通過初始化函數(shù)的返回值向外界提供了一個“帶檢查功能”的棧對象，后續(xù)用戶即可使用 stack_with_validate.h 文件中的push 和 pop 方法操作該對象。

	帶范圍檢查的棧使用范例如下：

	

	
//微信公眾號：嵌入式系統(tǒng)
#include"stack_with_range_check.h"
#include"stdio.h"

intmain()
{
intval;
intbuf[20];
inti;
inttest_data[5]={2,4,5,3,10};

structstack_with_range_checkstack;

structstack_with_validate*p_stack=stack_with_range_check_init(&stack,buf,20,1,9);

for(i=0;i

	

	

	無論何種檢查方式，其主要目的都是創(chuàng)建“帶檢查功能”的棧對象（完成抽象方法的實現(xiàn)）。創(chuàng)建完畢后，對于用戶操作方法都是完全相同的 stack_with_validate_push 和 stack_with_validate_pop ，與檢查方式無關。為避免贅述，這里不再實現(xiàn)另外兩種檢查功能的棧，僅展示出他們的類圖。

	

	在這里插入圖片描述

	在一些大型項目中，初始化過程往往和應用程序是分離的（即stack_with_range_check_init 內(nèi)部封閉不可見），也就是說，對于用戶來講，其僅會獲取到一個 struct stack_with_validate *類型的指針，其指向某個“帶檢查功能的棧”，實際檢查什么，用戶可能并不關心，應用程序基于該類型指針編程，將使應用程序與具體檢查功能無關，即使后續(xù)更換為其它檢查方式，應用程序也不需要做任何改動。

	4.4 抽象分離

	如果是硬件資源有限，功能單一或大概率無需擴展的嵌入式軟件開發(fā)，進行到這基本可以滿足需求；如果是復雜應用，且硬件資源充足還可繼續(xù)優(yōu)化。

	4.4.1 檢查功能抽象

	前面的實現(xiàn)中，將檢查功能視為棧的一種擴展（使用繼承），檢查邏輯直接在相應的擴展類中實現(xiàn)。這就使檢查功能與棧綁定在一起，檢查功能的實現(xiàn)無法獨立復用。如果要實現(xiàn)一個“帶檢查功能的隊列”，同樣是上述的 3 種檢查邏輯，期望能夠復用檢查邏輯相關的代碼。顯然，由于當前檢查邏輯的實現(xiàn)與棧捆綁在一起，無法單獨提取出來復用。

	檢查功能與棧的綁定，主要在“帶檢查功能的棧”中體現(xiàn)，該類的定義如下：

	

	
structstack_with_validate
{
structstacksuper;/*基類（超類）*/
int(*validate)(structstack_with_validate*p_this,intval);/*檢查函數(shù)*/
};


	

	

	super 用于繼承自普通棧，validate 表示一個抽象的數(shù)據(jù)檢查方法，不同的檢查方法，通過該指針所指向的函數(shù)體現(xiàn)。由于檢查方法validate是該類的一個方法，檢查邏輯與棧綁定。為了解綁分離，可以將檢查邏輯放到獨立的與棧無關的類中，額外定義一個抽象的校驗器類，專門表示數(shù)據(jù)檢查邏輯：

	

	
structvalidator
{
int(*validate)(structvalidator*p_this,intval);/*檢查函數(shù)*/
};


	

	

	雖然該類僅包含 validate 函數(shù)指針，但需注意該函數(shù)指針類型的變化，其第一個參數(shù)為指向校驗器的指針，而在“帶檢查功能的?！敝?，其第一個參數(shù)是指向“帶檢查功能的棧”的指針。通過該類的定義，明確的將檢查邏輯封裝到獨立的校驗器類中，與棧再無任何關聯(lián)。不同的檢查邏輯，可以在其子類中實現(xiàn)，校驗器類和各個子類之間的關系如下：

	

	由于校驗器類僅包含一個函數(shù)指針，因此其只需要在頭文件中定義出類即可，程序如下：

	校驗器類定義（validator.h）

	

	
#ifndef__VALIDATOR_H
#define__VALIDATOR_H

structvalidator
{
int(*validate)(structvalidator*p_this,intval);
};

staticinlineintvalidator_init(structvalidator*p_validator,
int(*validate)(structvalidator*,int))
{
p_validator->validate=validate;
return0;
}

staticinlineintvalidator_validate(structvalidator*p_validator,intval)/*校驗函數(shù)*/
{
if(p_validator->validate==NULL)/*校驗函數(shù)為空，視為無需校驗*/
{
return0;
}
returnp_validator->validate(p_validator,val);
}

#endif



	

	

	初始化函數(shù)負責為 validate 賦值，validator_validate 函數(shù)是校驗器對外提供的校驗函數(shù)，在其實現(xiàn)中僅調(diào)用了 validate 函數(shù)指針指向的函數(shù)。由于函數(shù)都比較簡單，因而直接使用了內(nèi)聯(lián)函數(shù)的形式進行了定義。接下來以范圍校驗為例，實現(xiàn)一個范圍校驗器。

	范圍校驗器 H 文件內(nèi)容（validator_range_check.h）

	

	
#ifndef__VALIDATOR_RANGE_CHECK_H
#define__VALIDATOR_RANGE_CHECK_H

#include"validator.h"
structvalidator_range_check
{
structvalidatorsuper;
intmin;
intmax;
};

structvalidator*validator_range_check_init(structvalidator_range_check*p_validator,intmin,intmax);

#endif


	

	

	范圍校驗器 C 文件內(nèi)容（validator_range_check.c）

	

	
//微信公眾號：嵌入式系統(tǒng)
#include"validator_range_check.h"

staticint_validate(structvalidator*p_this,intval)
{
structvalidator_range_check*p_stack=(structvalidator_range_check*)p_this;
if((val>=p_stack->min)&&(val<=?p_stack->max))
{
return0;/*檢查通過*/
}
return-1;
}

structvalidator*validator_range_check_init(structvalidator_range_check*p_validator,intmin,intmax)
{
validator_init(&p_validator->super,_validate);
p_validator->min=min;
p_validator->max=max;
return&p_validator->super;
}


	

	

	由于 validator_range_check 類僅用于實現(xiàn) validator 抽象類中定義的抽象方法，其初始化函數(shù)可以直接對外返回一個標準的校驗器（其中的抽象方法已實現(xiàn)）。按照同樣的方法，可以實現(xiàn)validator_oddeven_check 類和 validator_change_check 類。將檢查功能從“帶檢查功能的?！敝蟹蛛x出來之后，“帶檢查功能的?！敝芯蜔o需再維護檢查功能對應的抽象方法。其可以通過依賴的方式使用檢查功能，即依賴一個校驗器。在類圖中，依賴關系可以使用一個虛線箭頭表示，箭頭指向被依賴的類，示意圖如下：

	

	“帶檢查功能的?！鳖惗x如下：

	

	
structstack_with_validate
{
structstacksuper;/*基類（超類）*/
structvalidator*p_validator;/*依賴的校驗器*/
};


	

	

	與先前相比，其核心變化是由一個 validate 函數(shù)指針（指向具體的檢查方法）變更為 p_validator 指針（指向抽象的檢查方法），變化雖小，但是兩種截然不同的設計理念。之前的方式是定義了一個抽象方法，而現(xiàn)在的方式是依賴于一個校驗器對象。

	基于此更新“帶檢查功能的棧”類的實現(xiàn)如下：

	帶檢查功能的棧 H 文件更新（stack_with_validate.h）

	

	
#ifndef__STACK_WITH_VALIDATE_H
#define__STACK_WITH_VALIDATE_H

#include"stack.h"/*包含基類頭文件*/
#include"validator.h"

structstack_with_validate
{
structstacksuper;/*基類（超類）*/
structvalidator*p_validator;
};

intstack_with_validate_init(structstack_with_validate*p_stack,
int*p_buf,
intsize,
structvalidator*p_validator);

intstack_with_validate_push(structstack_with_validate*p_stack,intval);
intstack_with_validate_pop(structstack_with_validate*p_stack,int*p_val);

#endif


	

	

	帶檢查功能的棧 C 文件更新（stack_with_validate.c）

	

	
//微信公眾號：嵌入式系統(tǒng)
#include"stack_with_validate.h"
#include"stdio.h"

intstack_with_validate_init(structstack_with_validate*p_stack,
int*p_buf,
intsize,
structvalidator*p_validator)
{
stack_init(&p_stack->super,p_buf,size);
p_stack->p_validator=p_validator;
return0;
}

intstack_with_validate_push(structstack_with_validate*p_stack,intval)
{
if((p_stack->p_validator==NULL)||(validator_validate(p_stack->p_validator,val)==0))//注意差別
{
returnstack_push(&p_stack->super,val);
}
return-1;
}

intstack_with_validate_pop(structstack_with_validate*p_stack,int*p_val)
{
returnstack_pop(&p_stack->super,p_val);
}


	

	

	“帶檢查功能的?！钡膽媒涌冢╬ush 和 pop）并沒有發(fā)生任何改變，應用程序可以被復用，測試更新后的帶檢查功能的棧：

	

	
#include"stack_with_validate.h"
#include"validator_range_check.h"
#include"stdio.h"
intmain()
{
intbuf[20];
structstack_with_validatestack;
structvalidator_range_checkvalidator_range_check;

/*獲取范圍檢查校驗器*/
structvalidator*p_validator=validator_range_check_init(&validator_range_check,1,9);
stack_with_validate_init(&stack,buf,20,p_validator);

stack_validate_application(&stack);//使用和先前繼承方式一樣，實現(xiàn)忽略

return0;
}


	

	

	4.4.2 定義抽象棧

	定義校驗器類后，整個系統(tǒng)實現(xiàn)了兩種棧：普通棧和“帶檢查功能的?！?，無論什么棧，對于用戶來講都是實現(xiàn)入棧和出棧兩個核心邏輯。兩種棧提供兩種入棧和出棧方法。

	普通棧提供的方法為：

	

	
intstack_push(structstack*p_stack,intval);/*入棧*/
intstack_pop(structstack*p_stack,int*p_val);/*出棧*/


	

	

	“帶檢查功能的?！碧峁┑姆椒椋?/p>

	

	
intstack_with_validate_push(structstack_with_validate*p_stack,intval);/*入棧*/
intstack_with_validate_pop(structstack_with_validate*p_stack,int*p_val);/*出棧*/


	

	

	用戶執(zhí)行入棧和出棧操作，使用不同類的棧，調(diào)用的函數(shù)不同。通過多態(tài)思想，將入棧和出棧定義為抽象方法（函數(shù)指針），則可以達到這樣的效果：無論使用何種棧，都可以使用相同的方法來實現(xiàn)入棧和出棧?；诖硕x抽象棧。

	抽象棧類定義（stack.h）

	

	
#ifndef__STACK_H
#define__STACK_H

structstack
{
int(*push)(structstack*p_stack,intval);
int(*pop)(structstack*p_stack,int*p_val);
};

staticinlineintstack_init(structstack*p_stack,
int(*push)(structstack*,int),
int(*pop)(structstack*,int*))
{
p_stack->push=push;
p_stack->pop=pop;
}

staticinlineintstack_push(structstack*p_stack,intval)
{
returnp_stack->push(p_stack,val);
}

staticinlineintstack_pop(structstack*p_stack,int*p_val)
{
returnp_stack->pop(p_stack,p_val);
}

#endif


	

	

	基于抽象棧的定義，使用抽象棧提供的接口實現(xiàn)一個通用的應用程序，該應用程序與底層細節(jié)無關，任何棧都可以使用該應用程序進行測試。

	基于抽象棧實現(xiàn)的應用程序：

	

	
#include"stack.h"
#include"stdio.h"
intstack_application(structstack*p_stack)
{
inti;
intval;
inttest_data[5]={2,4,5,3,10};

for(i=0;i

	

	

	先有應用層代碼再有底層代碼。在實現(xiàn)具體棧之前，就可以開始編寫應用程序（微信公眾號【嵌入式系統(tǒng)】這就是依賴倒置原則，可參考《嵌入式軟件設計原則隨想》）。實現(xiàn)普通棧：

	普通棧 H 文件內(nèi)容（stack_normal.h）

	

	
#ifndef__STACK_NORMAL_H
#define__STACK_NORMAL_H

#include"stack.h"
structstack_normal
{
structstacksuper;
inttop;/*棧頂*/
int*p_buf;/*棧緩存*/
unsignedintsize;/*棧緩存的大小*/
};

structstack*stack_normal_init(structstack_normal*p_stack,int*p_buf,intsize);

#endif


	

	

	普通棧 C 文件內(nèi)容（stack_normal.c）

	

	
//微信公眾號：嵌入式系統(tǒng)
#include"stack_normal.h"

staticint_push(structstack*p_this,intval)
{
structstack_normal*p_stack=(structstack_normal*)p_this;
if(p_stack->top!=p_stack->size)
{
p_stack->p_buf[p_stack->top++]=val;
return0;
}
return-1;
}

staticint_pop(structstack*p_this,int*p_val)
{
structstack_normal*p_stack=(structstack_normal*)p_this;
if(p_stack->top!=0)
{
*p_val=p_stack->p_buf[--p_stack->top];
return0;
}
return-1;
}

structstack*stack_normal_init(structstack_normal*p_stack,int*p_buf,intsize)
{
p_stack->top=0;
p_stack->size=size;

p_stack->p_buf=p_buf;
stack_init(&p_stack->super,_push,_pop);
return&p_stack->super;
}


	

	

	基于普通類的實現(xiàn)，測試普通棧類：

	

	
#include"stack_normal.h"
intmain()
{
intbuf[20];

structstack_normalstack;
structstack*p_stack=stack_normal_init(&stack,buf,20);
stack_application(p_stack);
return0;
}


	

	

	“帶檢查功能的棧”是在普通棧的基礎上，增加了檢查功能，實現(xiàn)范例程序如下：

	帶檢查功能的棧 H 文件更新（stack_with_validate.h）

	

	
#ifndef__STACK_WITH_VALIDATE_H
#define__STACK_WITH_VALIDATE_H

#include"stack.h"/*包含基類頭文件*/
#include"validator.h"


structstack_with_validate
{

structstacksuper;/*基類（超類）*/
structstack*p_normal_stack;/*依賴于普通棧的實現(xiàn)*/
structvalidator*p_validator;
};

structstack*stack_with_validate_init(structstack_with_validate*p_stack,
structstack*p_normal_stack,
structvalidator*p_validator);

#endif


	

	

	檢查功能的棧 C 文件更新（stack_with_validate.c）

	

	
#include"stack_with_validate.h"
#include"stdio.h"
staticint_push(structstack*p_this,intval)
{
structstack_with_validate*p_stack=(structstack_with_validate*)p_this;
if((p_stack->p_validator==NULL)||(validator_validate(p_stack->p_validator,val)==0))
{
returnstack_push(p_stack->p_normal_stack,val);
}
return-1;
}

staticint_pop(structstack*p_this,int*p_val)
{
structstack_with_validate*p_stack=(structstack_with_validate*)p_this;
returnstack_pop(p_stack->p_normal_stack,p_val);
}

structstack*stack_with_validate_init(structstack_with_validate*p_stack,
structstack*p_normal_stack,
structvalidator*p_validator)
{
stack_init(&p_stack->super,_push,_pop);

p_stack->p_validator=p_validator;
p_stack->p_normal_stack=p_normal_stack;
return&p_stack->super;
}


	

	

	基于“帶檢查功能的?！钡膶崿F(xiàn)，測試范例如下：

	

	
#include"stack_normal.h"
#include"stack_with_validate.h"
#include"validator_range_check.h"

intmain()
{
intbuf[20];
structstack_normalstack;
structstack_with_validatestack_with_validate;
structvalidator_range_checkvalidator_range_check;

structstack*p_stack_normal=stack_normal_init(&stack,buf,20);

structvalidator*p_validator=validator_range_check_init(&validator_range_check,1,9);
structstack*p_stack=stack_with_validate_init(&stack_with_validate,
p_stack_normal,
p_validator);

stack_application(p_stack);
return0;
}


	

	

	由此可見，無論底層的各種棧如何實現(xiàn)，對于上層應用來講，其可以使用同一套接口stack_application操作各種各樣不同的棧。

	多種多態(tài)示例的核心解決方案都是相同的，即：定義抽象方法（函數(shù)指針），使上層應用可以使用同一套接口訪問不同的對象。從類的角度看，每個類中操作的規(guī)約都是相同的，而這些類可以用不同的方式實現(xiàn)這些同名的操作，從而使得擁有相同接口的對象可以在運行時相互替換。

	同樣的應用程序，可以在多個硬件平臺上運行，更換硬件時應用程序無需作任何改動。在嵌入式系統(tǒng)中，相同功能芯片的更新替換，也是多態(tài)應用最多的場景，根據(jù)硬件差異多態(tài)封裝，應用層無感使用相同接口。基于多態(tài)的思想實現(xiàn)“與硬件無關”的應用程序，還可以衍生出兩個概念：抽象接口與依賴倒置，它們的核心都是多態(tài)。更多編碼原則可參考《嵌入式軟件設計原則隨想》、《Unix哲學之編程原則》，分層架構(gòu)《嵌入式軟件分層隔離的典范》。

	5 小節(jié)

	學會了屠龍技，但是沒有龍，怎么辦？有些東西只是一種思維模式，作為日常開發(fā)工作中潛移默化的一種偏愛。所以嵌入式軟件開發(fā)究竟有沒對象呢？有但少。