几个值得学习的C编程习惯

秒速五厘米 2022-11-05 09:57 213阅读 0赞

【推荐阅读】

[C语言指针-从底层原理到花式技巧，用图文和代码帮你讲解透彻][C_-]

[嵌入式工程师常用的宏定义][Link 1]

[C语言实现面向对象的原理][C]

[C语言中的结构体和联合体][C 1]

[万字整理，C语言最全入门笔记！][C 2]

### 引言 ###

编程习惯的培养需要的是一个长期的过程，需要不断地总结，积累，并且我们需要从意识上认识其重要性，一个良好的编程习惯对于我们能力的提高也是有巨大的帮助的。下面是笔者在阅读《专业嵌入式软件开发》这本书时所看到的一些关于编程好习惯的总结，特此记录和分享一下、

### 判断失败而非成功 ###

下面是一段简化过后的代码片段：

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 的出现，这能很大程度上提升代码的质量。

![虚线阴影分割线][format_png]

![format_png 1][]

5T技术资源大放送！包括但不限于：C/C++，Arm, Linux，Android，人工智能，单片机，树莓派，等等。在公众号内回复「peter」，即可免费获取！！

![format_png 2][] **记得点击****分享****、****赞****和****在看****，给我充点儿电吧**

[C_-]: http://mp.weixin.qq.com/s?__biz=MzIxMjE1MzU4OA%3D%3D&chksm=8f5d9c35b82a1523b9b36eb0612e21f525161b978109bfa56bb3cb4bae7de1a5eb179bcddfe1&idx=2&mid=2648922542&scene=21&sn=252c74e8afb4d2bd43dd8be0eb316d52#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzIxMjE1MzU4OA%3D%3D&chksm=8f5d9fe2b82a16f45c2593c1ef8e790b196cae16f22faf45b2996c115599ab27770e27e82529&idx=1&mid=2648922745&scene=21&sn=e5bbbd373d8db625fdc08652e7379193#wechat_redirect
[C]: http://mp.weixin.qq.com/s?__biz=MzIxMjE1MzU4OA%3D%3D&chksm=8f5d9d4db82a145b43f330dc5c3316069567e052f5360d477d427158220a7815b188b7489a56&idx=2&mid=2648922326&scene=21&sn=8e5233b82999a085827cfacbdf380cf6#wechat_redirect
[C 1]: http://mp.weixin.qq.com/s?__biz=MzIxMjE1MzU4OA%3D%3D&chksm=8f5d9f2db82a163ba166c81da2c6a4d2fe0babd17fb564cdfdbad6a0c3e5ca92ed1fb2d4bab9&idx=1&mid=2648922806&scene=21&sn=3fb063f40dbb1619505e6b2a5872da5a#wechat_redirect
[C 2]: http://mp.weixin.qq.com/s?__biz=MzIxMjE1MzU4OA%3D%3D&chksm=8f5d9ed3b82a17c5b741e59fdc1dfd8f5ab7602ea08322b78e64edad4cba42641d4a09eb4657&idx=2&mid=2648922952&scene=21&sn=fa8a1abf2278b51d9b98ebc634f5a628#wechat_redirect
[format_png]: /images/20221023/56f21535f439433d8d3665c58bcddc97.png
[format_png 1]: /images/20221023/2eba63ea69df4fceb8fd58af3a73cba7.png
[format_png 2]: /images/20221023/cd92b0170bc04c4183b25a98b9dc9935.png