C 語言編程習慣總結
筆者能力有限，如果文中出現錯誤的地方，還請各位朋友能夠給我指出來，我將不勝感激，謝謝~
引言
編程習慣的培養需要的是一個長期的過程，需要不斷地總結，積累，並且我們需要從意識上認識其重要性，一個良好的編程習慣對於我們能力的提高也是由巨大的幫助的。下面是筆者在閱讀《專業嵌入式軟體開發》這本書時所看到的一些關於編程好習慣的總結，特此記錄和分享一下、
判斷失敗而非成功
下面是一段簡化過後的程式碼片段：
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 的出現，這能很大程度上提升程式碼的品質。
如果你覺得我的文章對你有所幫助，記得一鍵三連哦~，同時歡迎添加筆者微信相互交流，下面是筆者的微信名片
同時也歡迎大家關注本公眾號
