聊一聊C 语言编程习惯

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

 [[349354]]

引言

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

判断失败而非成功

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

  1. if (physap_alarm_init() == RV_SUCC) 
  2.     if (trx_alarm_init() == RV_SUCC) 
  3.     { 
  4.         if (bucket_init() == RV_SUCC) 
  5.         { 
  6.             if (main_bhp_init() == RV_SUCC) 
  7.             { 
  8.                 /* 正常代码 */ 
  9.             } 
  10.             else 
  11.             { 
  12.                 /* 错误代码 */ 
  13.             } 
  14.         } 
  15.         else 
  16.         { 
  17.             /* 错误代码 */ 
  18.         } 
  19.     } 
  20.     else 
  21.     { 
  22.         /* 错误代码 */ 
  23.     } 
  24. else 
  25.     /* 错误代码 */ 

可以看到上述代码在采用了判断成功策略后,代码中 if 和 else 之间的嵌套非常的混乱,看着非常的不直观,代码阅读比较困难,但是如果采用的是判断失败策略后,代码就会看起来简洁不少,下面是通过采用判断失败策略后改进的代码:

  1. if (physap_alarm_init() != RV_SUCC) 
  2.     /* 错误处理 */ 
  3.     return
  4.  
  5. if (trx_alarm_init() != RV_SUCC)  
  6.     /* 错误处理 */ 
  7.     return
  8.  
  9. if (bucket_init() != RV_SUCC) 
  10.     /* 错误处理 */ 
  11.     return
  12.  
  13. if (main_bhp_init() != RV_SUCC) 
  14.     /* 错误处理 */ 
  15.     return
  16.  
  17. /* 正常代码 */ 

通过上述代码可以知道,更改后的代码消除了 if 嵌套语句,大大提高了代码的可读性。需要注意的一点是,并不是所有的情况通过判断失败策略就能够优于判断成功策略,这需要视情况而定。

使用 sizeof 减少内存操作失误

在编写代码的时候,我们经常会涉及到使用 memset 函数对内存进行置 0 初始化,下面有几种错误示例:

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

上述代码的错误忘记了 buf 是一个字符指针数组,而非一个字符数组;

继续看一段代码:

  1. // example2 
  2. #define   DIGEST_LEN    17 
  3. #define   DIGEST_MAX    16 
  4.  
  5. char digest [DIGEST_MAX]; 
  6. memset (digest, 0, DIGEST_LEN); 

上述代码的错误是错用了宏,虽然错误比较低级,但是也犯错的可能性却挺高。

最后一个示例:

  1. // example3 
  2. dll_node_t *p_node = malloc (sizeof (dll_node_t)); 
  3. if (p_node == 0) 
  4.     return
  5. memset (p_node, 0, sizeof (dll_t)) 

上述代码的错误是在分配时是以 dll_node_t 类型为大小,而后面的 memset() 时却以 dll_t 类型为大小,造成了错误。

为了减少错误,下面代码使用了 sizeof 来避免了内存操作失误,首先来看例程 1 的改进版本:

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

紧接着来看示例2代码的改进版本:

  1. #define   DIGEST_LEN    17 
  2. #define   DIGEST_MAX    16 
  3.  
  4. char digest [DIGEST_MAX]; 
  5. memset (digest, 0, sizeof (digest)); 

示例3的改进版本:

  1. dll_node_t *p_node = malloc (sizeof (*p_node)); 
  2. if (0 == p_node) 
  3.     return
  4. memset (p_node, 0, sizeof (*p_node)) 

小结

通过上述代码可以得到这样一个小结论,使用 sizeof 时,以需要被初始化的目标变量名作为 sizeof() 的参数。可以简化为两条规则:

当目标变量是一个数组时,则采用 sizeof (变量名) 的格式获取内存的大小

当目标变量是一个指针时,则采用 sizeof (*指针变量名) 的格式获取内存的大小。

虽然上述例子是使用 memset 函数来介绍 sizeof ,但是这种方法可以运行到任何需要获取变量内存大小的场合。

屏蔽编程语言特性

数组在编程中是经常使用到的一个功能,下述是采用数组保存一个会话 ID 的一段简化代码:

  1. #define    SESSION_ID_LEN_MIN    1 
  2. #define    SESSION_ID_LEN_MAX    256 
  3.  
  4. char g_SessionId[SESSION_ID_LEN_MAX]; 
  5.  
  6. int save_session_id (char *_session_id, int _length) 
  7.     if (_length < SESSION_ID_LEN_MIN || _length > SESSION_ID_LEN_MAX) 
  8.     { 
  9.         return ERROR; 
  10.     } 
  11.  
  12.     memcpy (g_SessionId, session_id, _length); 
  13.     g_SessionId [_length] = '\0'
  14.  
  15.     return SUCESS; 

乍一看,可能觉得上述代码也没啥问题,但是在第一个 if 语句时,实际上当 _length 等于 SESSION_ID_LEN_MAX 时,数组实际上就已经越界了,所以上述代码实际上是存在问题的,那在更改时,可能会采取如下的方式进行更改。

  1. if (_length < SESSION_ID_LEN_MIN || _length >= SESSION_ID_LEN_MAX) 
  2.     return ERROR; 

这样进行更改逻辑上是不存在问题了, 但是代码却变得不是那么直观了,SESSION_ID_LEN_MAX 字面意思是会话 ID 的最大长度,那么这个最大长度按理来说应该是可以取到的才对,但是这里当 _length 等于SESSION_ID_LEN_MAX时,数组却溢出了,当看代码时看到 >= 时基本需要停下来思考一下,想着为什么不能等于 SESSION_ID_LEN_MAX ,不能做到直观的理解,因此,为了能够更好的且通顺的理解代码,那么可以这样来对代码进行修改:

  1. #define    SESSION_ID_LEN_MIN    1 
  2. #define    SESSION_ID_LEN_MAX    256 
  3.  
  4. /* 在此处进行更改 */ 
  5. char g_SessionId[SESSION_ID_LEN_MAX + 1]; 
  6.  
  7. int save_session_id (char *_session_id, int _length) 
  8.     if (_length < SESSION_ID_LEN_MIN || _length > SESSION_ID_LEN_MAX) 
  9.     { 
  10.         return ERROR; 
  11.     } 
  12.  
  13.     memcpy (g_SessionId, session_id, _length); 
  14.     g_SessionId [_length] = '\0'
  15.  
  16.     return SUCESS; 

通过上述的更改,也就是让 SESSION_ID_LEN_MAX 的值减 一,那么这个时候 _length 的值也就可以取到 SESSION_ID_LEN_MAX 了,代码阅读起来也就更加地直观了。

恰当地使用 goto 语句

我们在接触 C 语言编程的时候,大多都被告知不要使用 goto 语句,以至于有时候一看到 goto 语句就觉得程序写的很垃圾,但真实情况是什么样呢,在编程的时候 goto 语句并没有被禁用,并且如果 goto 运用的好的话,能够大大简化程序,以及提高程序的可读性和维护性,下面是没有使用 goto 语句的一段代码,其中存在多处错误处理代码,代码如下所示:

  1. int queue_init (queue ** _pp_queue, int _size) 
  2.     pthread_mutexattr attr; 
  3.     queue *queue; 
  4.  
  5.     queue = (queue_t *)malloc(sizeof(queue_t)); 
  6.     if (0 == queue) 
  7.     { 
  8.         return -1; 
  9.     } 
  10.     *_pp_queue = queue; 
  11.  
  12.     memset (queue, 0, sizeof (*queue)); 
  13.     queue->size_ = _size; 
  14.     pthread_mutexattr_init (&attr); 
  15.     if (0 != pthread_mutex_init(&queue->mutex_, &attr)) 
  16.     { 
  17.         pthread_mutexattr_destroy (&attr); 
  18.         free (queue); 
  19.         return -1; 
  20.     } 
  21.     queue->messages_ = (void**) malloc (queue->size_ * sizeof (void *)); 
  22.  
  23.     if (0 == queue->messages_) 
  24.     { 
  25.         pthread_mutexattr_destroy (&attr); 
  26.         free (queue); 
  27.         return -1; 
  28.     } 
  29.     if (0 != sem_init(&queue->sem_put_, 0, queue->size)) 
  30.     { 
  31.         free (queue->message_); 
  32.         pthread_mutexattr_destroy (&attr); 
  33.         free (queue); 
  34.         return -1; 
  35.     } 
  36.     pthread_mutexattr_destroy (&attr); 
  37.     return 0; 

通过上述代码可以看出在进行错误处理时,很容易出现遗漏,并且代码看起来也比较臃肿,下面是用了 goto 语句之后的代码:

  1. int queue_init (queue ** _pp_queue, int _size) 
  2.     pthread_mutexattr attr; 
  3.     queue *queue; 
  4.  
  5.     queue = (queue_t *)malloc(sizeof(queue_t)); 
  6.     if (0 == queue) 
  7.     { 
  8.         return -1; 
  9.     } 
  10.     *_pp_queue = queue; 
  11.  
  12.     memset (queue, 0, sizeof (*queue)); 
  13.     queue->size_ = _size; 
  14.     pthread_mutexattr_init (&attr); 
  15.     if (0 != pthread_mutex_init(&queue->mutex_, &attr)) 
  16.     { 
  17.         goto error; 
  18.     } 
  19.     queue->messages_ = (void**) malloc (queue->size_ * sizeof (void *)); 
  20.  
  21.     if (0 == queue->messages_) 
  22.     { 
  23.         goto error; 
  24.     } 
  25.     if (0 != sem_init(&queue->sem_put_, 0, queue->size)) 
  26.     { 
  27.         goto error1; 
  28.     } 
  29.     pthread_mutexattr_destroy (&attr); 
  30.     return 0; 
  31.  
  32. error1: 
  33.     free (queue->messages_); 
  34. error: 
  35.     pthread_mutexattr_destory (&attr); 
  36.     free (queue); 
  37.     return -1; 

可以看到使用 goto 之后,代码的可读性变高了。在使用 goto 的时候也需要注意以下两点原则:

  • 不能滥用
  • 不要让 goto 语句形成一个环。使用 goto 语句应该形成一条线,

合理运用数组在多任务的编程环境中,有些任务的生命周期与整个程序的生命周期是相同的,他们在程序初始化时被创建,然后运行到程序结束,对于这样的任务,我们称之为具有全局生命周期,如果具有全局生命周期的任务需要内存资源,我们完全可以定义全局或静态数组的方式来替代动态分配的方式,下面是使用 malloc 来初始化全局变量 g_aaa_eap_str_buff 的代码:

  1. #define    MAX_AAA_SS_PORTS        64 
  2. #define    MAX_NUM_PADIUS_IDS      (MAX_AAA_SS_PORTS * 256) 
  3. #define    MAX_EAP_MESSAGE_LEN     4096 
  4.  
  5. static char **g_aaa_eap_str_buff; 
  6.  
  7. void thread_authenticator (void *_arg) 
  8.     g_aaa_eap_str_buff = (char **) malloc (MAX_NUM_PADIUS_IDS); 
  9.     if (0 == g_aaa_eap_str_buff) 
  10.     { 
  11.         log_error ("Failed to allocate buffer for storing eap string"); 
  12.         return
  13.     } 
  14.  
  15.     for (int i = 0; i < MAX_NUM_PADIUS_IDS; i++) 
  16.     { 
  17.         g_aaa_eap_str_buff [i] = (char *) malloc (MAX_EAP_MESSAGE_LEN); 
  18.         if (0 == g_aaa_eap_str_buff [i]) 
  19.         { 
  20.             log_error ("Failed to allocate buffer for storing eap string"); 
  21.         } 
  22.     } 
  23.  
  24.     while (1) 
  25.     { 
  26.         ... 
  27.     } 

上述代码是通过 malloc 来动态的获取内存,更好的方式是使用数组的方式来获取内存,而且这样做的好处之一是内存的释放也不需要我们控制,这也就降低了内存泄露的可能性。下面是代码示例:

  1. #define    MAX_AAA_SS_PORTS        64 
  2. #define    MAX_NUM_PADIUS_IDS      (MAX_AAA_SS_PORTS * 256) 
  3. #define    MAX_EAP_MESSAGE_LEN     4096 
  4.  
  5. char g_aaa_eap_str_buff [MAX_NUM_PADIUS_IDS][MAX_EAP_MESSAGE_LEN]; 
  6.  
  7. void thread_authenticator (void *_arg) 
  8.     while (1) 
  9.     { 
  10.         ...... 
  11.     } 

可以看出来,使用数组之后,代码量变的简洁了很多,但是也有一个地方是需要注意的:由于全局或者静态数组一旦定义,它所占用的内存在运行期间就不能被释放,因此在使用数组这种方式预留内存时,需要注意是否带来内存浪费问题。

结论

上述便是一部分关于编程细节的内容,可以看出来,合理的使用这些技巧,会让代码变得更改简洁,也能够增加代码的可读性,同时也能够减少 bug 的出现,这能很大程度上提升代码的质量。

本文转载自微信公众号「wenzi嵌入式软件」,可以通过以下二维码关注。转载本文请联系wenzi嵌入式软件公众号。

 

责任编辑:武晓燕 来源: wenzi嵌入式软件
相关推荐

2021-04-15 12:10:42

Go语言Go开发者

2020-10-23 07:00:00

C++函数

2022-08-30 07:39:57

C++namespace隔离

2018-06-07 13:17:12

契约测试单元测试API测试

2023-09-22 17:36:37

2020-05-22 08:16:07

PONGPONXG-PON

2021-01-28 22:31:33

分组密码算法

2021-03-29 00:02:10

C#Attribute元素

2020-06-28 09:30:37

Linux内存操作系统

2022-10-08 11:33:56

边缘计算云计算

2022-03-08 16:10:38

Redis事务机制

2018-01-10 14:13:04

测试矩阵API测试

2022-11-26 00:00:06

装饰者模式Component

2020-08-12 08:34:16

开发安全We

2021-01-01 09:01:05

前端组件化设计

2020-09-08 06:54:29

Java Gradle语言

2022-03-29 09:56:21

游戏版本运营

2019-12-17 10:06:18

CDMA高通4G

2023-10-12 09:58:45

操作符C++

2022-08-08 08:25:21

Javajar 文件
点赞
收藏

51CTO技术栈公众号