平時(shí)主要還是C語(yǔ)言用的比較多，對(duì)C語(yǔ)言做一個(gè)總結(jié)吧，最基本的就不寫了，把一下覺得重要的點(diǎn)總結(jié)一下吧。

• static關(guān)鍵字

  static有兩種用法：

  1. 修飾變量，將變量放在靜態(tài)區(qū)進(jìn)行存儲(chǔ)
  2. 修飾符號(hào)，static聲明的變量名（函數(shù)名）僅能在文件內(nèi)部訪問，其實(shí)編譯器的處理就是在編譯的時(shí)候會(huì)對(duì)符號(hào)增加一個(gè)前綴，外部文件直接訪問這個(gè)符號(hào)在鏈接的時(shí)候肯定是找不到的。要注意的是由于C語(yǔ)言并沒有名稱空間的概念，所以為了避免名稱污染，在編寫程序的時(shí)候應(yīng)該將僅文件內(nèi)部使用的函數(shù)和變量聲明為static。

• volatile

  1. 告訴編譯器不要優(yōu)化針對(duì)這個(gè)變量的訪問，在嵌入式當(dāng)中可能會(huì)出現(xiàn)你在等一個(gè)值的狀態(tài)變化，但是這個(gè)值的狀態(tài)變化是在中斷中改變的。編譯器在優(yōu)化代碼時(shí)發(fā)現(xiàn)，你等待的一個(gè)變量狀態(tài)沒有其他地方會(huì)改變它可能就優(yōu)化掉了這個(gè)代碼從而造成錯(cuò)誤。當(dāng)然了理論上是會(huì)有這個(gè)問題，但是我目前并沒有遇到過，可能是現(xiàn)在的編譯器都足夠優(yōu)秀了吧。

• 指針

  C語(yǔ)言的另外一個(gè)迷惑點(diǎn)就是指針和數(shù)組，其實(shí)指針和數(shù)組的區(qū)別不大，都是通過一個(gè)符號(hào)指向一個(gè)內(nèi)存空間。只是一個(gè)是內(nèi)存空間位置可變和大小可變的（指針），一個(gè)是內(nèi)存空間位置和大小不可變的（數(shù)組）。

• define

  • 宏只是代碼展開，所以使用帶參數(shù)的宏時(shí)最好在使用參數(shù)時(shí)都加上括號(hào)，避免在參數(shù)為表達(dá)式時(shí)出現(xiàn)錯(cuò)誤。如：

    #define MIN(a, b) ((a) < (b) ? (a) : (b))
    

  • 有意思的宏

    以下代碼實(shí)現(xiàn)了通過定義OPTION_USER_DEVICE，動(dòng)態(tài)地聲明函數(shù)與調(diào)用函數(shù)。

        //設(shè)備函數(shù)聲明
        # define _DEVICE_INIT_DECLARATION(device) device##Init(void)
        # define DEVICE_INIT_DECLARATION(device) _DEVICE_INIT_DECLARATION(device)
    
        # define _DEVICE_POLL_DECLARATION(device) device##Poll(void)
        #define _CALL_DEVICE_FUNC(device, func, ...) device##func(__VA_ARGS__)
    
        #define CALL_DEVICE_FUNC(device, func, ...) _CALL_DEVICE_FUNC(device, func, __VA_ARGS__)
    
        //聲明
        void DEVICE_INIT_DECLARATION(OPTION_USER_DEVICE);
        void DEVICE_POLL_DECLARATION(OPTION_USER_DEVICE);
    
        int main(void)
        {
            //調(diào)用
            CALL_DEVICE_FUNC(OPTION_USER_DEVICE, Init);
            CALL_DEVICE_FUNC(OPTION_USER_DEVICE, Poll);
        }
    

• const

  最好能習(xí)慣性地給只讀的參數(shù)加上const修飾符，方便理解參數(shù)用途，如以下聲明：

    void strcpy(char *dst, const char *src);
  

• typedef

  • 將結(jié)構(gòu)體定義成類型，方面使用。

  typedef struct Item_st
  {
      char name[20];
      int value;
  }Item_t;
  

  • 定義回調(diào)函數(shù)的函數(shù)指針類型

  typedef void (*Callback_t)(void);
  
  void Start(Callback cb);
  

• 字節(jié)序

  網(wǎng)絡(luò)或通信的數(shù)據(jù)要注意字節(jié)序的問題。

• 常用的C標(biāo)準(zhǔn)庫(kù)

  • stdlib（malloc, free）
  • string (memcpy, strcpy)
  • stdio (printf, sprintf)

• 位運(yùn)算（|, &, ^）

• printf

  多用printf輸出日志調(diào)試，一般我會(huì)在工程里定義一個(gè)Log宏

  #define LOG(...) printf("%s::%s[%d]", __FILE__, __func__, __LINE__);printf(__VA_ARGS__);printf("\n")
  

單片機(jī)相關(guān)

• 中斷處理函數(shù)

  盡量不要在中斷中處理耗時(shí)的任務(wù)，一般只是在中斷中讀出數(shù)據(jù)或置一個(gè)標(biāo)志位，在主循環(huán)中再進(jìn)行處理。

• 單片機(jī)的日志打印

  在單片機(jī)上一般使用串口來輸出日志信息，像iar或keil這類工具都支持通過printf來打印日志，只是需要實(shí)現(xiàn)putc，在putc中將輸出轉(zhuǎn)向UART。

常用數(shù)據(jù)結(jié)構(gòu)

這里說說常用的數(shù)據(jù)結(jié)構(gòu)，主要還是靜態(tài)循環(huán)隊(duì)列和鏈表兩種。

• 靜態(tài)循環(huán)隊(duì)列

  靜態(tài)循環(huán)隊(duì)列一般用于數(shù)據(jù)緩存方面，如串口通信時(shí)，在中斷中讀數(shù)據(jù)并將數(shù)據(jù)入隊(duì)，在主循環(huán)里再?gòu)年?duì)列里將數(shù)據(jù)讀出并處理。

• 鏈表

  鏈表用處就很廣了，一般支持3個(gè)操作，插入，刪除，遍歷。動(dòng)態(tài)規(guī)模的數(shù)據(jù)需要存儲(chǔ)就都可以用鏈表來存。

具體的這里封裝了兩個(gè)頭文件（es_fifo.h, es_list.h），可以看一下。

es_fifo.h

#ifndef __ES_FIFO_H
#define __ES_FIFO_H

#define ES_FIFO(name) (name)

#define _ES_FIFO_SIZE(fifo) (sizeof(ES_FIFO(fifo).items) / sizeof(ES_FIFO(fifo).items[0]))

#define es_fifo_def(type, fifo, size) \
struct fifo##_st\
{ \
unsigned short front, back, count; \
type items[size]; \
}ES_FIFO(fifo)

#define es_fifo_in(fifo, item) \
do{ \
if(es_fifo_has_space(fifo)) \
{ \
ES_FIFO(fifo).items[ES_FIFO(fifo).back] = item; \
ES_FIFO(fifo).back = ES_FIFO(fifo).back + 1; \
ES_FIFO(fifo).back = ES_FIFO(fifo).back == _ES_FIFO_SIZE(fifo) ? 0 : ES_FIFO(fifo).back; \
ES_FIFO(fifo).count++; \
} \
}while(0)

#define es_fifo_has_space(fifo) (ES_FIFO(fifo).count < _ES_FIFO_SIZE(fifo))

#define es_fifo_is_empty(fifo) (ES_FIFO(fifo).count == 0)

#define es_fifo_count(fifo) ES_FIFO(fifo).count

#define es_fifo_peek(fifo) ES_FIFO(fifo).items[ES_FIFO(fifo).front]

#define es_fifo_out(fifo) \
do{ \
if(!es_fifo_is_empty(fifo)) \
{ \
    ES_FIFO(fifo).front = (ES_FIFO(fifo).front + 1); \
    ES_FIFO(fifo).front = ES_FIFO(fifo).front == _ES_FIFO_SIZE(fifo) ? 0 : ES_FIFO(fifo).front; \
    ES_FIFO(fifo).count--; \
} \
}while(0)


#endif // __ES_FIFO_H

es_list.h

#ifndef __ES_LIST_H
#define __ES_LIST_H

#define ES_LIST_ENTRY(type) \
type *next;type *prev

#define es_list_first(list) ((list) ? (list) : NULL)

#define es_list_last(list) ((list) ? (list)->prev : NULL)

#define es_list_add(list, node) \
if(!list) { \
    list = node; \
    list->next = list; \
    list->prev = list; \
} \
else { \
    node->next = list; \
    list->prev->next = node; \
    node->prev = list->prev; \
    list->prev = node; \
}

#define es_list_del(list, node) \
{ \
    list = node == list ? (node->next == list ? NULL : node->next) : list; \
    (node)->prev->next = (node)->next; \
    (node)->next->prev = (node)->prev; \
} 

#define ___ESLISTV(node, line) node##line
#define __ESLISTV(node, line) ___ESLISTV(node, line)
#define _ESLISTV(node) __ESLISTV(node, __LINE__)

#define es_list_foreach(list, node) \
node = list; \
void *_ESLISTV(_next) = node ? node->next : NULL; \
void *_ESLISTV(_flag) = NULL; \
void *_ESLISTV(_list) = list; \
for(; list && (node != (list) \
    || _ESLISTV(_flag) == NULL); \
        node = _ESLISTV(_next), \
        _ESLISTV(_next) = node->next, \
        _ESLISTV(_flag) = _ESLISTV(_list) != list ? NULL : list, _ESLISTV(_list) = list)

#endif // __ES_LIST_H