1、聊一聊

本文是bug菌為大家整理的好文，C語言其實是非常簡潔的語言，語法相比那些高級語言可以說非常小巧了，然而C語言在嵌入式中卻有著其獨特的魅力，本文為大家展示了C語言在嵌入式中的特色，大家參考學習一下。

文章中也融入了bug菌的一些觀點，僅供大家學習參考！

2、前言

本文從語法上來說C語言并不復雜， 但編寫優質可靠的嵌入式C程序并非易事，不僅需要熟知硬件特性和缺陷，還需要對編譯原理和計算機技術知識有著一定的了解。

本文以嵌入式實踐為基礎，再結合相關資料, 闡述嵌入式需要了解的C語言知識和重點，希望每個讀到這篇文章的人都能有所收獲。

3、關鍵字

關鍵字是C語言中具有特殊功能的保留標示符，按照功能可分為**

1). 數據類型(常用char, short, int, long, unsigned, float, double)

2). 運算和表達式( =, +, -, *, while, do-while, if, goto, switch-case)

3). 數據存儲(auto， static， extern，const， register，volatile，restricted)，

4). 結構(struct, enum, union,typedef),

5). 位操作和邏輯運算(<<, >>, &, |, ~，^, &&)，

6). 預處理(#define, #include, #error，#if...#elif...#else...#endif等)，

7). 平臺擴展關鍵字(__asm, __inline，__syscall)

這些關鍵字共同構成了嵌入式平臺的C語法。

（bugPS：平臺擴展關鍵字大家可以到各個平臺手冊中查找，往往這些擴展能夠幫助大家更好的調試程序等，不過也會存在跨平臺可移植性問題）

嵌入式的應用從邏輯上可以抽象為三個部分：

1). 數據的輸入(如傳感器，信號，接口輸入),

2). 數據的處理(如協議的解碼和封包，AD采樣值的轉換等)

3). 數據的輸出(GUI的顯示，輸出的引腳狀態，DA的輸出控制電壓，PWM波的占空比等)，

對于數據的管理就貫穿著整個嵌入式應用的開發，它包含數據類型，存儲空間管理，位和邏輯操作，以及數據結構，C語言從語法上支撐上述功能的實現，并提供相應的優化機制，以應對嵌入式下更受限的資源環境。

4、數據類型

C語言支持常用的字符型，整型，浮點型變量，有些編譯器如keil還擴展支持bit(位)和sfr(寄存器)等數據類型來滿足特殊的地址操作。 C語言只規定了每種基本數據類型的最小取值范圍，因此在不同芯片平臺上相同類型可能占用不同長度的存儲空間，這就需要在代碼實現時考慮后續移植的兼容性，而C語言提供的typedef就是用于處理這種情況的關鍵字，在大部分支持跨平臺的軟件項目中被采用，典型的如下:

typedefunsignedcharuint8_t; typedefunsignedshortuint16_t; typedefunsignedintuint32_t; ...... typedefsignedintint32_t;

既然不同平臺的基本數據寬度不同，那么如何確定當前平臺的基礎數據類型如int的寬度，這就需要C語言提供的接口sizeof，實現如下。

printf("int size:%d, short size:%d, char size:%d ",sizeof(int),sizeof(char),sizeof(short));

這里還有重要的知識點，就是指針的寬度，如

char*p； printf("point p size:%d ",sizeof(p));

其實這就和芯片的可尋址寬度有關，如32位MCU的寬度就是4，64位MCU的寬度就是8，在有些時候這也是查看MCU位寬比較簡單的方式。

(bugPS:在熟悉一款新的芯片時候，直接把這些參數打印出來，不然這些注意點比較零碎在文檔上查找比較麻煩)

5、內存管理與存儲架構

C語言允許程序變量在定義時就確定內存地址，通過作用域，以及關鍵字extern，static，實現了精細的處理機制，按照在硬件的區域不同，內存分配有三種方式(節選自C++高質量編程)：

1). 從靜態存儲區域分配內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。 例如全局變量，static 變量。

2). 在棧上創建。 在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。 棧內存分配運算內置于處理器的指令集中 ，效率很高，但是分配的內存容量有限。 (bugPS:不過還是存在入棧和出棧的時間消耗)

3). 從堆上分配，亦稱動態內存分配。 程序在運行的時候用 malloc 或 new 申請任意多少的內存，程序員自己負責在何時用 free 或 delete 釋放內存。 動態內存的生存期由程序員決定，使用非常靈活，但同時遇到問題也最多。 (bugPS:這一塊也是最容易出問題的，分配了不釋放，釋放了又訪問都是不正確的，也是非常考驗程序員的編程素質)

這里先看個簡單的C語言實例。

//main.c #include #include staticintst_val; //靜態全局變量 -- 靜態存儲區 intex_val; //全局變量 -- 靜態存儲區 intmain(void) { inta=0; //局部變量 -- 棧上申請 int*ptr=NULL; //指針變量 staticintlocal_st_val=0; //靜態變量 local_st_val+=1; a=local_st_val; ptr=(int*)malloc(sizeof(int));//從堆上申請空間 if(ptr!=NULL) { printf("*p value:%d",*ptr); free(ptr); ptr=NULL; //free后需要將ptr置空，否則會導致后續ptr的校驗失效，出現野指針 } }

C語言的作用域不僅描述了標識符的可訪問的區域，其實也規定了變量的存儲區域，在文件作用域的變量st_val和ex_val被分配到靜態存儲區，其中static關鍵字主要限定變量能否被其它文件訪問，而代碼塊作用域中的變量a, ptr和local_st_val 則要根據類型的不同，分配到不同的區域，其中a是局部變量，被分配到棧中，ptr作為指針，由malloc分配空間，因此定義在堆中，而local_st_val則被關鍵字限定，表示分配到靜態存儲區。

這里就涉及到重要知識點，static在文件作用域和代碼塊作用域的意義是不同的：在文件作用域用于限定函數和變量的外部鏈接性(能否被其它文件訪問), 在代碼塊作用域則用于將變量分配到靜態存儲區。 (bugPS：這里的代碼塊一般指的是用大括號括起來的區域，當然文件中的static同樣也是分配到靜態全局存儲區)

對于C語言，如果理解上述知識對于內存管理基本就足夠，但對于嵌入式C來說，定義一個變量，它不一定在內存(SRAM)中，也有可能在FLASH空間，或直接由寄存器存儲(register定義變量或者高優化等級下的部分局部變量)，如:

定義為const的全局變量定義在Flash中(BugPS：對于MCU一般都會放在Flash，不過具體還是需要看對應的映射文件，參考:【MCU】一種單片機節省內存的方法(補充);

定義為register的局部變量會被優化到直接放在通用寄存器中(bugPS:register修飾的僅僅是可能分配到:具體可以參考:頓悟,神秘的register關鍵字(C語言篇))，在優化運行速度，或者存儲受限時，理解這部分知識對于代碼的維護就很有意義。

此外，嵌入式C語言的編譯器中會擴展內存管理機制，如支持分散加載機制和__attribute__((section("用戶定義區域")))，允許指定變量存儲在特殊的區域如(SDRAM, SQI FLASH), 這強化了對內存的管理，以適應復雜的應用環境場景和需求。

LD_ROM 0x00800000 0x10000 { ;load region size_region
    EX_ROM 0x00800000 0x10000 { ;load address = execution address
  *.o (RESET, +First)
  *(InRoot$$Sections)
  .ANY (+RO)
  }
  EX_RAM 0x20000000 0xC000 { ;rw Data
    .ANY (+RW +ZI)
  }
  EX_RAM1 0x2000C000 0x2000 {
    .ANY(MySection)
   }
  EX_RAM2 0x40000000 0x20000{
    .ANY(Sdram)
  }
}


int a[10] __attribute__((section("Mysection")));
intb[100]__attribute__((section("Sdram")));

采用這種方式，我們就可以將變量指定到需要的區域，這在某些情況下是必須的，如做GUI或者網頁時因為要存儲大量圖片和文檔，內部FLASH空間可能不足，這時就可以將變量聲明到外部區域，另外內存中某些部分的數據比較重要，為了避免被其它內容覆蓋，可能需要單獨劃分SRAM區域，避免被誤修改導致致命性的錯誤， 這些經驗在實際的產品開發中是常用且重要，不過因為篇幅原因，這里只簡略的提供例子，如果工作中遇到這種需求，建議詳細去了解下。

至于堆的使用，對于嵌入式Linux來說，使用起來和標準C語言一致，注意malloc后的檢查，釋放后記得置空，避免"野指針“，不過對于資源受限的單片機來說，使用malloc的場景一般較少，如果需要頻繁申請內存塊的場景，都會構建基于靜態存儲區和內存塊分割的一套內存管理機制，一方面效率會更高(用固定大小的塊提前分割， 在使用時直接查找編號處理)，另一方面對于內存塊的使用可控，可以有效避免內存碎片的問題，常見的如RTOS和網絡LWIP都是采用這種機制，我個人習慣也采用這種方式，所以關于堆的細節不在描述，如果希望了解，可以參考中關于存儲相關的說明。

6、指針與數組

數組和指針往往是引起程序bug的主要原因，如數組越界，指針越界，非法地址訪問，非對齊訪問，這些問題背后往往都有指針和數組的影子，因此理解和掌握指針和數組，是成為合格C語言開發者的必經之路。

數組是由相同類型元素構成，當它被聲明時，編譯器就根據內部元素的特性在內存中分配一段空間，另外C語言也提供多維數組，以應對特殊場景的需求，而指針則是提供使用地址的符號方法，只有指向具體的地址才有意義，C語言的指針具有最大的靈活性，在被訪問前，可以指向任何地址，這大大方便了對硬件的操作，但同時也對開發者有了更高的要求。 參考如下代碼。

intmain(void)
{
  char cval[] = "hello";
  int i;
  int ival[] = {1, 2, 3, 4};
  int arr_val[][2] = {{1, 2}, {3, 4}};
  const char *pconst = "hello";
  char *p;
  int *pi;
  int *pa;
  int **par;


  p = cval;
  p++;            //addr增加1
  pi = ival;
  pi+=1;          //addr增加4
  pa = arr_val[0];
  pa+=1;          //addr增加4
  par = arr_val;
  par++;         //addr增加8
  for(i=0; i
 對于數組來說，一般從0開始獲取值，以length-1作為結束，通過[0, length)半開半閉區間訪問，這一般不會出問題，但是某些時候，我們需要倒著讀取數組時，有可能錯誤的將length作為起始點，從而導致訪問越界，另外在操作數組時，有時為了節省空間，將訪問的下標變量i定義為unsigned char類型，而C語言中unsigned char類型的范圍是0~255，如果數組較大，會導致數組超過時無法截止，從而陷入死循環，這種在最初代碼構建時很容易避免，但后期如果更改需求，在加大數組后，在使用數組的其它地方都會有隱患，需要特別注意。

   在前面提到過，指針占有的空間與芯片的尋址寬度有關，32位平臺為4字節，64位為8字節，而指針的加減運算中的長度又與它的類型相關，如char類型為1，int類型為4，如果你仔細觀察上面的代碼就會發現par的值增加了8，這是因為指向指針的指針，對應的變量是指針，也就是長度就是指針類型的長度，在64位平臺下為8，如果在32位平臺則為4，這些知識理解起來并不困難，但是這些特性在工程運用中稍有不慎，就會埋下不易察覺的問題。另外指針還支持強制轉換，這在某些情況下相當有用，參考如下代碼：

#include 


typedef struct
{
  int b;
  int a;
}STRUCT_VAL;
static __align(4) char arr[8] = {0x12, 0x23, 0x34, 0x45, 0x56, 0x12, 0x24, 0x53};
int main(void)
{
    STRUCT_VAL *pval;
    int *ptr;
    pval = (STRUCT_VAL *)arr;
    ptr = (int *)&arr[4];
    printf("val:%d, %d", pval->a, pval->b);
    printf("val:%d,", *ptr);
}
//0x45342312 0x53241256
//0x53241256

基于指針的強制轉換，在協議解析，數據存儲管理中高效快捷的解決了數據解析的問題(bugPS:bug菌之前的文章也有提到過，強轉結構體直接索引解析，還是比較好用的)，但是在處理過程中涉及的數據對齊，大小端，是常見且十分易錯的問題，如上面arr字符數組，通過__align(4)強制定義為4字節對齊是必要的，這里可以保證后續轉換成int指針訪問時，不會觸發非對齊訪問異常，如果沒有強制定義，char默認是1字節對齊的，當然這并不就是一定觸發異常(由整個內存的布局決定arr的地址，也與實際使用的空間是否支持非對齊訪問有關，如部分SDRAM使用非對齊訪問時，會觸發異常), 這就導致可能增減其它變量，就可能觸發這種異常，而出異常的地方往往和添加的變量毫無關系，而且代碼在某些平臺運行正常，切換平臺后觸發異常，這種隱蔽的現象是嵌入式中很難查找解決的問題。
另外，C語言指針還有特殊的用法就是通過強制轉換給特定的物理地址訪問，通過函數指針實現回調，如下：

#include 


typedef int (*pfunc)(int, int);
int func_add(int a, int b){
 return a+b;
}
int main(void)
{
    pfunc *func_ptr;
    *（volatile uint32_t *）0x20001000 = 0x01a23131;
    func_ptr = func_add;
    printf("%d
", func_ptr(1, 2));
}

這里說明下，volatile易變的，可變的，一般用于以下幾種狀況：
1）并行設備的硬件寄存器（如：狀態寄存器）
2）一個中斷服務子程序中會訪問到的非自動變量（Non-automatic variables)
3）多線程應用中被幾個任務共享的變量

volatile可以解決用戶模式和異常中斷訪問同一個變量時，出現的不同步問題，另外在訪問硬件地址時，volatile也阻止對地址訪問的優化，從而確保訪問的實際的地址，精通volatile的運用，在嵌入式底層中十分重要，也是嵌入式C從業者的基本要求之一。函數指針在一般嵌入式軟件的開發中并不常見，但對許多重要的實現如異步回調，驅動模塊，使用函數指針就可以利用簡單的方式實現很多應用，當然我這里只能說是拋磚引玉，許多細節知識是值得詳細去了解掌握的。

7、結構體類型與對齊

C語言提供自定義數據類型來描述一類具有相同特征點的事務，主要支持的有結構體，枚舉和聯合體。其中枚舉通過別名限制數據的訪問，可以讓數據更直觀，易讀，實現如下：

typedefenum{spring=1,summer,autumn,winter}season; seasons1=summer; 聯合體的是能在同一個存儲空間里存儲不同類型數據的數據類型，對于聯合體的占用空間，則是以其中占用空間最大的變量為準，如下：

typedef union{     
  char c;     
  short s;     
  int i; 
}UNION_VAL;


UNION_VAL val; 
int main(void) 
{     
  printf("addr:0x%x, 0x%x, 0x%x
",            
         (int)(&(val.c)), (int)(&(val.s)), (int)(&(val.i)));     
  val.i = 0x12345678;     
  if(val.s == 0x5678)         
    printf("小端模式
");       
  else         
    printf("大端模式
");     
} 
/*
addr:0x407970, 0x407970, 0x407970 
小端模式
*/

聯合體的用途主要通過共享內存地址的方式，實現對數據內部段的訪問，這在解析某些變量時，提供了更為簡便的方式，此外測試芯片的大小端模式也是聯合體的常見應用，當然利用指針強制轉換，也能實現該目的,實現如下：

int data = 0x12345678; 
short *pdata = (short *)&data; 
if(*pdata = 0x5678)     
  printf("%s
", "小端模式"); 
else   
printf("%s
","大端模式");

可以看出使用聯合體在某些情況下可以避免對指針的濫用。
結構體則是將具有共通特征的變量組成的集合，比起C++的類來說，它沒有安全訪問的限制，不支持直接內部帶函數，但通過自定義數據類型，函數指針，仍然能夠實現很多類似于類的操作，對于大部分嵌入式項目來說，結構化處理數據對于優化整體架構以及后期維護大有便利，下面舉例說明：

typedef int (*pfunc)(int, int); 
typedef struct{     
  int num;     
  int profit;     
  pfunc get_total; 
}STRUCT_VAL;


int GetTotalProfit(int a, int b)
{     
  return a*b; 
}  


int main(void){     
  STRUCT_VAL Val;     
  STRUCT_VAL *pVal;      
  Val.get_total = GetTotalProfit;     
  Val.num = 1;     
  Val.profit = 10;     
  printf("Total:%d
",  Val.get_total(Val.num, Val.profit));  //變量訪問    
  pVal = &Val;     
  printf("Total:%d
",  pVal->get_total(pVal->num, pVal->profit)); //指針訪問 
} 
/* 
Total:10 
Total:10 
*/

C語言的結構體支持指針和變量的方式訪問，通過轉換可以解析任意內存的數據(如我們之前提到的通過指針強制轉換解析協議)，另外通過將數據和函數指針打包，在通過指針傳遞，是實現驅動層實接口切換的重要基礎，有著重要的實踐意義，另外基于位域，聯合體，結構體，可以實現另一種位操作，這對于封裝底層硬件寄存器具有重要意義，實踐如下：

typedef unsigned char uint8_t; 
  union reg{     
    struct{         
    uint8_t bit0:1;         
    uint8_t bit1:1;         
    uint8_t bit2_6:5;         
    uint8_t bit7:1;     
  }bit;     
  uint8_t all; 
}; 


int main(void)
{     
  union reg RegData;     
  RegData.all = 0;      
  RegData.bit.bit0 = 1;     
  RegData.bit.bit7 = 1;     
  printf("0x%x
", RegData.all);      
  RegData.bit.bit2_6 = 0x3;     
  printf("0x%x
", RegData.all); 
} 
/* 
0x81 
0x8d
*/

通過聯合體和位域操作，可以實現對數據內bit的訪問，這在寄存器以及內存受限的平臺(bugPS：省內存的辦法)，提供了簡便且直觀的處理方式，另外對于結構體的另一個重要知識點就是對齊了，通過對齊訪問，可以大幅度提高運行效率，但是因為對齊引入的存儲長度問題，也是容易出錯的問題，對于對齊的理解，可以分類為如下說明。
基礎數據類型：以默認的的長度對齊，如char以1字節對齊，short以2字節對齊等
數組 ：按照基本數據類型對齊，第一個對齊了后面的自然也就對齊了。
聯合體 ：按其包含的長度最大的數據類型對齊。
結構體：結構體中每個數據類型都要對齊，結構體本身以內部最大數據類型長度對齊

union DATA{     
  int a;     
  char b; 
};  
struct BUFFER0{     
  union DATA data;     
  char a;     
  //reserved[3]     
  int b;     
  short s;     
  //reserved[2] 
}; //16字節  
struct BUFFER1{     
  char a;              
  //reserved[0]     
  short s;    
  union DATA data;     
  int b; 
};//12字節  


int main(void) 
{     
  struct BUFFER0 buf0;     
  struct BUFFER1 buf1;          
  printf("size:%d, %d
", sizeof(buf0), sizeof(buf1));     
  printf("addr:0x%x, 0x%x, 0x%x, 0x%x
",              
       (int)&(buf0.data), (int)&(buf0.a), (int)&(buf0.b), (int)&(buf0.s));          
  printf("addr:0x%x, 0x%x, 0x%x, 0x%x
",              
       (int)&(buf1.a), (int)&(buf1.s), (int)&(buf1.data), (int)&(buf1.b)); 
} 
/* 
size:16, 12 
addr:0x61fe10, 0x61fe14, 0x61fe18, 0x61fe1c 
addr:0x61fe04, 0x61fe06, 0x61fe08, 0x61fe0c 
*/

其中union聯合體的大小與內部最大的變量int一致，為4字節，根據讀取的值，就知道實際內存布局和填充的位置是一致，事實上學會通過填充來理解C語言的對齊機制，是有效且快捷的方式。

8、預處理機制

C語言提供了豐富的預處理機制，方便了跨平臺的代碼的實現，此外C語言通過宏機制實現的數據和代碼塊替換，字符串格式化，代碼段切換，對于工程應用具有重要意義，下面按照功能需求，描述在C語言運用中的常用預處理機制。
#include 包含文件命令，在C語言中，它執行的效果是將包含文件中的所有內容插入到當前位置，這不只包含頭文件，一些參數文件，配置文件，也可以使用該文件插入到當前代碼的指定位置。其中<>和""分別表示從標準庫路徑還是用戶自定義路徑開始檢索。
#define宏定義，常見的用法包含定義常量或者代碼段別名，當然某些情況下配合##格式化字符串，可以實現接口的統一化處理，實例如下：

#define MAX_SIZE  10
#define MODULE_ON  1
#define ERROR_LOOP() do{
                     printf("error loop
");
                   }while(0);
#define global(val) g_##val
int global(v) = 10;
int global(add)(int a, int b)
{
    return a+b;
｝

#if..#elif...#else...#endif， #ifdef..#endif, #ifndef...#endif條件選擇判斷，條件選擇主要用于切換代碼塊，這種綜合性項目和跨平臺項目中為了滿足多種情況下的需求往往會被使用。
#undef取消定義的參數，避免重定義問題。
#error，#warning用于用戶自定義的告警信息，配合#if，#ifdef使用，可以限制錯誤的預定義配置。
#pragma帶參數的預定義處理，常見的#pragma pack(1), 不過使用后會導致后續的整個文件都以設置的字節對齊，配合push和pop可以解決這種問題，代碼如下：

#pragma pack(push)
#pragma pack(1)
struct TestA
{
   char i;
   int b;
}A;
#pragma pack(pop); //注意要調用pop，否則會導致后續文件都以pack定義值對齊，執行不符合預期
等同于
 struct _TestB{  
   char i;
   int b;
}__attribute__((packed))A;

9、總結

如果你看到了這里，那么應該對C語言有了比較清晰的認識，嵌入式C語言在處理硬件物理地址，位操作，內存訪問，都給予開發者了充分的自由，通過數組，指針以及強制轉換的技巧，可以有效減少數據處理中的復制過程，這對于底層是必要的，也方便了整個架構的開發。

但是由這種自由帶來的非法訪問，溢出，越界，以及不同硬件平臺對齊，數據寬度，大小端問題，在功能設計人員手里一般還能夠處理，對于后續接手項目的人來說，如果本身的設計沒有考慮清楚這些問題，往往代表著問題和麻煩，所以對于任何嵌入式C的從業者，清晰的掌握這些基礎的知識和必要的。

講到這里，關于嵌入式C語言的初步總結就到此為止，但C語言在嵌入式運用的中的重點和難點并不僅僅只有這些，如嵌入式C語言支持的內聯匯編，通訊間的可靠性實現，存儲數據校驗和完整性保證，這些工程上的運用和技巧，都很難用簡單的言語說清楚，另外有關異常觸發后的查找和解決的技巧，也值得詳細的說明，這里因為篇幅以及自己還未整理清晰，就先到此為止。

審核編輯：湯梓紅