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教程