C 語言編程習慣總結

時間  2020-10-30
標籤 node 編程 數組 微信 session 編程語言 函數 指針 code 生命週期 欄目 C&C++ 简体版
原文   原文鏈接

筆者能力有限，若是文中出現錯誤的地方，還請各位朋友可以給我指出來，我將不勝感激，謝謝~node

引言

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

判斷失敗而非成功

下面是一段簡化事後的代碼片斷：數組

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 嵌套語句，大大提升了代碼的可讀性。須要注意的一點是，並非全部的狀況經過判斷失敗策略就可以優於判斷成功策略，這須要視狀況而定。session

使用 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);

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

最後一個示例：生命週期

// 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 的出現，這能很大程度上提高代碼的質量。

若是你以爲個人文章對你有所幫助，記得一鍵三連哦~，同時歡迎添加筆者微信相互交流，下面是筆者的微信名片
微信名片
同時也歡迎你們關注本公衆號
微信公衆號

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程