[[349354]]

引言

編程習慣的培養需要的是一個長期的過程，需要不斷地總結，積累，并且我們需要從意識上認識其重要性，一個良好的編程習慣對于我們能力的提高也是有巨大的幫助的。下面是筆者在閱讀《專業嵌入式軟件開發》這本書時所看到的一些關于編程好習慣的總結，特此記錄和分享一下、

判斷失敗而非成功

下面是一段簡化過后的代碼片段：

if (physap_alarm_init() == RV_SUCC) 
{ 
    if (trx_alarm_init() == RV_SUCC) 
    { 
        if (bucket_init() == RV_SUCC) 
        { 
            if (main_bhp_init() == RV_SUCC) 
            { 
                /* 正常代碼 */ 
            } 
            else 
            { 
                /* 錯誤代碼 */ 
            } 
        } 
        else 
        { 
            /* 錯誤代碼 */ 
        } 
    } 
    else 
    { 
        /* 錯誤代碼 */ 
    } 
} 
else 
{ 
    /* 錯誤代碼 */ 
} 

可以看到上述代碼在采用了判斷成功策略后，代碼中 if 和 else 之間的嵌套非常的混亂，看著非常的不直觀，代碼閱讀比較困難，但是如果采用的是判斷失敗策略后，代碼就會看起來簡潔不少，下面是通過采用判斷失敗策略后改進的代碼：

if (physap_alarm_init() != RV_SUCC) 
{ 
    /* 錯誤處理 */ 
    return; 
} 
 
if (trx_alarm_init() != RV_SUCC)  
{ 
    /* 錯誤處理 */ 
    return; 
} 
 
if (bucket_init() != RV_SUCC) 
{ 
    /* 錯誤處理 */ 
    return; 
} 
 
if (main_bhp_init() != RV_SUCC) 
{ 
    /* 錯誤處理 */ 
    return; 
} 
 
/* 正常代碼 */ 

通過上述代碼可以知道，更改后的代碼消除了 if 嵌套語句，大大提高了代碼的可讀性。需要注意的一點是，并不是所有的情況通過判斷失敗策略就能夠優于判斷成功策略，這需要視情況而定。

使用 sizeof 減少內存操作失誤

在編寫代碼的時候，我們經常會涉及到使用 memset 函數對內存進行置 0 初始化，下面有幾種錯誤示例：

// example1 
char *buf[MAX_LEN + 1]; 
memset (buf, 0, MAX_LEN + 1); 

上述代碼的錯誤忘記了 buf 是一個字符指針數組，而非一個字符數組;

繼續看一段代碼：

// example2 
#define   DIGEST_LEN    17 
#define   DIGEST_MAX    16 
 
char digest [DIGEST_MAX]; 
memset (digest, 0, DIGEST_LEN); 

上述代碼的錯誤是錯用了宏，雖然錯誤比較低級，但是也犯錯的可能性卻挺高。

最后一個示例：

// example3 
dll_node_t *p_node = malloc (sizeof (dll_node_t)); 
if (p_node == 0) 
{ 
    return; 
} 
memset (p_node, 0, sizeof (dll_t)) 

上述代碼的錯誤是在分配時是以 dll_node_t 類型為大小，而后面的 memset() 時卻以 dll_t 類型為大小，造成了錯誤。

為了減少錯誤，下面代碼使用了 sizeof 來避免了內存操作失誤，首先來看例程 1 的改進版本：

char *buf [MAX_LEN + 1]; 
memset (buf, 0, sizeof (buf)); 

緊接著來看示例2代碼的改進版本：

#define   DIGEST_LEN    17 
#define   DIGEST_MAX    16 
 
char digest [DIGEST_MAX]; 
memset (digest, 0, sizeof (digest)); 

示例3的改進版本：

dll_node_t *p_node = malloc (sizeof (*p_node)); 
if (0 == p_node) 
{ 
    return; 
} 
memset (p_node, 0, sizeof (*p_node)) 

小結

通過上述代碼可以得到這樣一個小結論，使用 sizeof 時，以需要被初始化的目標變量名作為 sizeof() 的參數。可以簡化為兩條規則：

當目標變量是一個數組時，則采用 sizeof (變量名) 的格式獲取內存的大小

當目標變量是一個指針時，則采用 sizeof (*指針變量名) 的格式獲取內存的大小。

雖然上述例子是使用 memset 函數來介紹 sizeof ，但是這種方法可以運行到任何需要獲取變量內存大小的場合。

屏蔽編程語言特性

數組在編程中是經常使用到的一個功能，下述是采用數組保存一個會話 ID 的一段簡化代碼：

#define    SESSION_ID_LEN_MIN    1 
#define    SESSION_ID_LEN_MAX    256 
 
char g_SessionId[SESSION_ID_LEN_MAX]; 
 
int save_session_id (char *_session_id, int _length) 
{ 
    if (_length < SESSION_ID_LEN_MIN || _length > SESSION_ID_LEN_MAX) 
    { 
        return ERROR; 
    } 
 
    memcpy (g_SessionId, session_id, _length); 
    g_SessionId [_length] = '\0'; 
 
    return SUCESS; 
} 

乍一看，可能覺得上述代碼也沒啥問題，但是在第一個 if 語句時，實際上當 _length 等于 SESSION_ID_LEN_MAX 時，數組實際上就已經越界了，所以上述代碼實際上是存在問題的，那在更改時，可能會采取如下的方式進行更改。

if (_length < SESSION_ID_LEN_MIN || _length >= SESSION_ID_LEN_MAX) 
{ 
    return ERROR; 
} 

這樣進行更改邏輯上是不存在問題了， 但是代碼卻變得不是那么直觀了，SESSION_ID_LEN_MAX 字面意思是會話 ID 的最大長度，那么這個最大長度按理來說應該是可以取到的才對，但是這里當 _length 等于SESSION_ID_LEN_MAX時，數組卻溢出了，當看代碼時看到 >= 時基本需要停下來思考一下，想著為什么不能等于 SESSION_ID_LEN_MAX ，不能做到直觀的理解，因此，為了能夠更好的且通順的理解代碼，那么可以這樣來對代碼進行修改：

#define    SESSION_ID_LEN_MIN    1 
#define    SESSION_ID_LEN_MAX    256 
 
/* 在此處進行更改 */ 
char g_SessionId[SESSION_ID_LEN_MAX + 1]; 
 
int save_session_id (char *_session_id, int _length) 
{ 
    if (_length < SESSION_ID_LEN_MIN || _length > SESSION_ID_LEN_MAX) 
    { 
        return ERROR; 
    } 
 
    memcpy (g_SessionId, session_id, _length); 
    g_SessionId [_length] = '\0'; 
 
    return SUCESS; 
} 

通過上述的更改，也就是讓 SESSION_ID_LEN_MAX 的值減 一，那么這個時候 _length 的值也就可以取到 SESSION_ID_LEN_MAX 了，代碼閱讀起來也就更加地直觀了。

恰當地使用 goto 語句

我們在接觸 C 語言編程的時候，大多都被告知不要使用 goto 語句，以至于有時候一看到 goto 語句就覺得程序寫的很垃圾，但真實情況是什么樣呢，在編程的時候 goto 語句并沒有被禁用，并且如果 goto 運用的好的話，能夠大大簡化程序，以及提高程序的可讀性和維護性，下面是沒有使用 goto 語句的一段代碼，其中存在多處錯誤處理代碼，代碼如下所示：

int queue_init (queue ** _pp_queue, int _size) 
{ 
    pthread_mutexattr attr; 
    queue *queue; 
 
    queue = (queue_t *)malloc(sizeof(queue_t)); 
    if (0 == queue) 
    { 
        return -1; 
    } 
    *_pp_queue = queue; 
 
    memset (queue, 0, sizeof (*queue)); 
    queue->size_ = _size; 
    pthread_mutexattr_init (&attr); 
    if (0 != pthread_mutex_init(&queue->mutex_, &attr)) 
    { 
        pthread_mutexattr_destroy (&attr); 
        free (queue); 
        return -1; 
    } 
    queue->messages_ = (void**) malloc (queue->size_ * sizeof (void *)); 
 
    if (0 == queue->messages_) 
    { 
        pthread_mutexattr_destroy (&attr); 
        free (queue); 
        return -1; 
    } 
    if (0 != sem_init(&queue->sem_put_, 0, queue->size)) 
    { 
        free (queue->message_); 
        pthread_mutexattr_destroy (&attr); 
        free (queue); 
        return -1; 
    } 
    pthread_mutexattr_destroy (&attr); 
    return 0; 
} 

通過上述代碼可以看出在進行錯誤處理時，很容易出現遺漏，并且代碼看起來也比較臃腫，下面是用了 goto 語句之后的代碼：

int queue_init (queue ** _pp_queue, int _size) 
{ 
    pthread_mutexattr attr; 
    queue *queue; 
 
    queue = (queue_t *)malloc(sizeof(queue_t)); 
    if (0 == queue) 
    { 
        return -1; 
    } 
    *_pp_queue = queue; 
 
    memset (queue, 0, sizeof (*queue)); 
    queue->size_ = _size; 
    pthread_mutexattr_init (&attr); 
    if (0 != pthread_mutex_init(&queue->mutex_, &attr)) 
    { 
        goto error; 
    } 
    queue->messages_ = (void**) malloc (queue->size_ * sizeof (void *)); 
 
    if (0 == queue->messages_) 
    { 
        goto error; 
    } 
    if (0 != sem_init(&queue->sem_put_, 0, queue->size)) 
    { 
        goto error1; 
    } 
    pthread_mutexattr_destroy (&attr); 
    return 0; 
 
error1: 
    free (queue->messages_); 
error: 
    pthread_mutexattr_destory (&attr); 
    free (queue); 
    return -1; 
} 

可以看到使用 goto 之后，代碼的可讀性變高了。在使用 goto 的時候也需要注意以下兩點原則：

• 不能濫用
• 不要讓 goto 語句形成一個環。使用 goto 語句應該形成一條線，

合理運用數組在多任務的編程環境中，有些任務的生命周期與整個程序的生命周期是相同的，他們在程序初始化時被創建，然后運行到程序結束，對于這樣的任務，我們稱之為具有全局生命周期，如果具有全局生命周期的任務需要內存資源，我們完全可以定義全局或靜態數組的方式來替代動態分配的方式，下面是使用 malloc 來初始化全局變量 g_aaa_eap_str_buff 的代碼：

#define    MAX_AAA_SS_PORTS        64 
#define    MAX_NUM_PADIUS_IDS      (MAX_AAA_SS_PORTS * 256) 
#define    MAX_EAP_MESSAGE_LEN     4096 
 
static char **g_aaa_eap_str_buff; 
 
void thread_authenticator (void *_arg) 
{ 
    g_aaa_eap_str_buff = (char **) malloc (MAX_NUM_PADIUS_IDS); 
    if (0 == g_aaa_eap_str_buff) 
    { 
        log_error ("Failed to allocate buffer for storing eap string"); 
        return; 
    } 
 
    for (int i = 0; i < MAX_NUM_PADIUS_IDS; i++) 
    { 
        g_aaa_eap_str_buff [i] = (char *) malloc (MAX_EAP_MESSAGE_LEN); 
        if (0 == g_aaa_eap_str_buff [i]) 
        { 
            log_error ("Failed to allocate buffer for storing eap string"); 
        } 
    } 
 
    while (1) 
    { 
        ... 
    } 
} 

上述代碼是通過 malloc 來動態的獲取內存，更好的方式是使用數組的方式來獲取內存，而且這樣做的好處之一是內存的釋放也不需要我們控制，這也就降低了內存泄露的可能性。下面是代碼示例：

#define    MAX_AAA_SS_PORTS        64 
#define    MAX_NUM_PADIUS_IDS      (MAX_AAA_SS_PORTS * 256) 
#define    MAX_EAP_MESSAGE_LEN     4096 
 
char g_aaa_eap_str_buff [MAX_NUM_PADIUS_IDS][MAX_EAP_MESSAGE_LEN]; 
 
void thread_authenticator (void *_arg) 
{ 
    while (1) 
    { 
        ...... 
    } 
} 

可以看出來，使用數組之后，代碼量變的簡潔了很多，但是也有一個地方是需要注意的：由于全局或者靜態數組一旦定義，它所占用的內存在運行期間就不能被釋放，因此在使用數組這種方式預留內存時，需要注意是否帶來內存浪費問題。

結論

上述便是一部分關于編程細節的內容，可以看出來，合理的使用這些技巧，會讓代碼變得更改簡潔，也能夠增加代碼的可讀性，同時也能夠減少 bug 的出現，這能很大程度上提升代碼的質量。

本文轉載自微信公眾號「wenzi嵌入式軟件」，可以通過以下二維碼關注。轉載本文請聯系wenzi嵌入式軟件公眾號。