代码安全性和健壮性：如何在if和assert中做选择?

  •  一、前言
  • 二、assert 断言
  • 三、if VS assert
  • 四、总结

一、前言

云阳网站建设公司成都创新互联公司,云阳网站设计制作，有大型网站制作公司丰富经验。已为云阳上千余家提供企业网站建设服务。企业网站搭建\外贸网站制作要多少钱，请找那个售后服务好的云阳做网站的公司定做！

我们在撸代码的时候，经常需要对代码的安全性进行检查，例如：

1. 指针是否为空?

2. 被除数是否为 0?

3. 函数调用的返回结果是否有效?

4. 打开一个文件是否成功?

对这一类的边界条件进行检查的手段，一般都是使用 if 或者 assert 断言，无论使用哪一个，都可以达到检查的目的。那么是否就意味着：这两者可以随便使用，想起来哪个就用哪个?

这篇小短文我们就来掰扯掰扯：在不同的场景下，到底是应该用 if，还是应该使用 assert 断言?

写这篇文章的时候，我想起了孔乙己老先生的那个问题：茴香豆的“茴”字有几种写法?

似乎我们没有必要来纠结应该怎么选择，因为都能够实现想要的功能。以前我也是这么想的，但是，现在我不这么认为。

成为技术大牛、拿到更好的offer，也许就在这些细微之间就分出了胜负。

二、assert 断言

刚才，我问了下旁边的一位工作 5 年多的嵌入式开发者：if 和 assert 如何选择?他说：assert 是干什么的?!

看来，有必要先简单说一下 assert 断言。

assert() 的原型是：

 
 
 
    
  
  
  
  1. void assert(int expression); 
    2.

1. 如果宏的参数求值结果为非零值，则不做任何操作(no action);

2. 如果宏的参数是零值，就打印诊断消息，然后调用abort()。

例如下面的代码：

 
 
 
    
  
  
  
  1. #include  
    2. 
  
  
  
  2. int my_div(int a, int b) 
    3. 
  
  
  
  3. { 
    4. 
  
  
  
  4.     assert(0 != b); 
    5. 
  
  
  
  5.     return a / b; 
    6. 
  
  
  
  6. } 
    7.

1. 当 b 不为 0 时，assert 断言什么都不做，程序往下执行;

2. 当 b 为 0 时，assert 断言就打印错误信息，然后终止程序;

从功能上来说，assert(0 != b); 与下面的代码等价：

 
 
 
    
  
  
  
  1. if (0 == b) 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     fprintf(stderr, "b is zero..."); 
    4. 
  
  
  
  4.     abort(); 
    5. 
  
  
  
  5. } 
    6.

assert 是一个宏，不是一个函数

在 assert.h 头文件中，有如下定义：

 
 
 
    
  
  
  
  1. #ifdef NDEBUG 
    2. 
  
  
  
  2.     #define assert(condition) ((void)0) 
    3. 
  
  
  
  3. #else 
    4. 
  
  
  
  4.     #define assert(condition) /*implementation defined*/ 
    5. 
  
  
  
  5. #endif 
    6.

既然是宏定义，说明是在预处理的时候进行宏替换。

从上面的定义中可以看到：

  1. 如果定义了宏 NDEBUG，那么 assert() 宏将不做什么动作，也就是相当于一条空语句：(void)0;，当在 release 阶段编译代码的时候，都会在编译选项中(Makefile)定义这个宏。
  2. 如果没有定义宏 NDEBUG，那么 assert() 宏将会把一些检查代码进行替换，我们在开发阶段执行 debug 模式编译时，一般都会屏蔽掉这 NDEBUG 这个宏。

三、if VS assert

还是以一个代码片段来描述问题，以场景化来讨论比较容易理解。

 
 
 
    
  
  
  
  1. // brief: 把两个短字符串拼接成一个字符串 
    2. 
  
  
  
  2. char *my_concat(char *str1, char *str2) 
    3. 
  
  
  
  3. { 
    4. 
  
  
  
  4.     int len1 = strlen(str1); 
    5. 
  
  
  
  5.     int len2 = strlen(str2); 
    6. 
  
  
  
  6.     int len3 = len1 + len2; 
    7. 
  
  
  
  7.     char *new_str = (char *)malloc(len3 + 1); 
    8. 
  
  
  
  8.     memset(new_str, 0 len3 + 1); 
    9. 
  
  
  
  9.     sprintf(new_str, "%s%s", str1, str2); 
    10. 
  
  
  
  10.     return new_str; 
    11. 
  
  
  
  11. } 
    12.

如果一个开发人员写出上面的代码，一定会被领导约谈的!它存在下面这些问题：

  1. 没有对输入参数进行有效性检查;
  2. 没有对 malloc 的结果进行检查;
  3. sprintf 的效率很低;
  4. ...

1. 使用 if 语句来检查

 
 
 
    
  
  
  
  1. char *my_concat(char *str1, char *str2) 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     if (!str1 || !str2)  // 参数错误 
    4. 
  
  
  
  4.         return NULL; 
    5. 
  
  
  
  5.          
    6. 
  
  
  
  6.     int len1 = strlen(str1); 
    7. 
  
  
  
  7.     int len2 = strlen(str2); 
    8. 
  
  
  
  8.     int len3 = len1 + len2; 
    9. 
  
  
  
  9.     char *new_str = (char *)malloc(len3 + 1); 
    10. 
  
  
  
  10.      
    11. 
  
  
  
  11.     if (!new_str)   // 申请堆空间失败 
    12. 
  
  
  
  12.         return NULL; 
    13. 
  
  
  
  13.      
    14. 
  
  
  
  14.     memset(new_str, 0 len3 + 1); 
    15. 
  
  
  
  15.     sprintf(new_str, "%s%s", str1, str2); 
    16. 
  
  
  
  16.     return new_str; 
    17. 
  
  
  
  17. } 
    18.

2. 使用 assert 断言来检查

 
 
 
    
  
  
  
  1. char *my_concat(char *str1, char *str2) 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     // 确保参数正确 
    4. 
  
  
  
  4.     assert(NULL != str1); 
    5. 
  
  
  
  5.     assert(NULL != str2); 
    6. 
  
  
  
  6.      
    7. 
  
  
  
  7.     int len1 = strlen(str1); 
    8. 
  
  
  
  8.     int len2 = strlen(str2); 
    9. 
  
  
  
  9.     int len3 = len1 + len2; 
    10. 
  
  
  
  10.     char *new_str = (char *)malloc(len3 + 1); 
    11. 
  
  
  
  11.      
    12. 
  
  
  
  12.     // 确保申请堆空间成功 
    13. 
  
  
  
  13.     assert(NULL != new_str); 
    14. 
  
  
  
  14.      
    15. 
  
  
  
  15.     memset(new_str, 0 len3 + 1); 
    16. 
  
  
  
  16.     sprintf(new_str, "%s%s", str1, str2); 
    17. 
  
  
  
  17.     return new_str; 
    18. 
  
  
  
  18. } 
    19.

3. 你喜欢哪一个?

首先声明一点：以上这 2 种检查方式，在实际的代码中都很常见，从功能上来说似乎也没有什么影响。因此，没有严格的错与对之分，很多都是依赖于每个人的偏好习惯不同而已。

(1) assert 支持者

我作为 my_concat() 函数的实现者，目的是拼接字符串，那么传入的参数必须是合法有效的，调用者需要负责这件事。如果传入的参数无效，我会表示十分的惊讶!怎么办：崩溃给你看!

(2)if 支持者

我写的 my_concat() 函数十分的健壮，我就预料到调用者会乱搞，故意的传入一些无效参数，来测试我的编码水平。没事，来吧，我可以处理任何情况!

这两个派别的理由似乎都很充足!那究竟该如何选择?难道真的的跟着感觉走吗?

假设我们严格按照常规的流程去开发一个项目：

1. 在开发阶段，编译选项中不定义 NDEBUG 这个宏，那么 assert 就发挥作用;

2. 项目发布时，编译选项中定义了 NDEBUG 换个宏，那么 assert 就相当于空语句;

也就是说，只有在 debug 开发阶段，用 assert 断言才能够正确的检查到参数无效。而到了 release 阶段，assert 不起作用，如果调用者传递了无效参数，那么程序只有崩溃的命运了。

这说明什么问题?是代码中存在 bug?还是代码写的不够健壮?

从我个人的理解上看，这压根就是单元测试没有写好，没有测出来参数无效的这个 case!

4. assert 的本质

assert 就是为了验证有效性，它最大作用就是：在开发阶段，让我们的程序尽可能地 crash。每一次的 crash，都意味着代码中存在着 bug，需要我们去修正。

当我们写下一个 assert 断言的时候，就说明：断言失败的这种情况是不可以的，是不被允许的。必须保证断言成功，程序才能继续往下执行。

5. if-else 的本质

if-else 语句用于逻辑处理，它是为了处理各种可能出现的情况。就是说：每一个分支都是合理的，是允许出现的，我们都要对这些分支进行处理。

6. 我喜欢的版本

 
 
 
    
  
  
  
  1. char *my_concat(char *str1, char *str2) 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     // 参数必须有效 
    4. 
  
  
  
  4.     assert(NULL != str1); 
    5. 
  
  
  
  5.     assert(NULL != str2); 
    6. 
  
  
  
  6.      
    7. 
  
  
  
  7.     int len1 = strlen(str1); 
    8. 
  
  
  
  8.     int len2 = strlen(str2); 
    9. 
  
  
  
  9.     int len3 = len1 + len2; 
    10. 
  
  
  
  10.     char *new_str = (char *)malloc(len3 + 1); 
    11. 
  
  
  
  11.      
    12. 
  
  
  
  12.     // 申请堆空间失败的情况，是可能的，是允许出现的情况。 
    13. 
  
  
  
  13.     if (!new_str) 
    14. 
  
  
  
  14.         return NULL; 
    15. 
  
  
  
  15.      
    16. 
  
  
  
  16.     memset(new_str, 0 len3 + 1); 
    17. 
  
  
  
  17.     sprintf(new_str, "%s%s", str1, str2); 
    18. 
  
  
  
  18.     return new_str; 
    19. 
  
  
  
  19. } 
    20.

对于参数而言：我认为传入的参数必须是有效的，如果出现了无效参数，说明代码中存在 bug，不允许出现这样的情况，必须解决掉。

对于资源分配结果(malloc 函数)而言：我认为资源分配失败是合理的，是有可能的，是允许出现的，而且我也对这个情况进行了处理。

当然了，并不是说对参数检查就要使用 assert，主要是根据不同的场景、语义来判断。例如下面的这个例子：

 
 
 
    
  
  
  
  1. int g_state; 
    2. 
  
  
  
  2. void get_error_str(bool flag) 
    3. 
  
  
  
  3. { 
    4. 
  
  
  
  4.     if (TRUE == flag) 
    5. 
  
  
  
  5.     { 
    6. 
  
  
  
  6.         g_state = 1; 
    7. 
  
  
  
  7.         assert(1 == g_state); // 确保赋值成功 
    8. 
  
  
  
  8.     } 
    9. 
  
  
  
  9.     else 
    10. 
  
  
  
  10.     { 
    11. 
  
  
  
  11.         g_state = 0; 
    12. 
  
  
  
  12.         assert(0 == g_state); // 确保赋值成功 
    13. 
  
  
  
  13.     } 
    14. 
  
  
  
  14. } 
    15.

flag 参数代表不同的分支情况，而赋值给 g_state 之后，必须保证赋值结果的正确性，因此使用 assert 断言。

四、总结

这篇文章分析了 C 语言中比较晦涩、模糊的一个概念，似乎有点虚无缥缈，但是的确又需要我们停下来仔细考虑一下。

如果有些场景，实在拿捏不好，我就会问自己一个问题：

这种情况是否被允许出现?

不允许：就用 assert 断言，在开发阶段就尽量找出所有的错误情况;

允许：就用 if-else，说明这是一个合理的逻辑，需要进行下一步处理。

本文转载自微信公众号「IOT物联网小镇」，可以通过以下二维码关注。转载本文请联系IOT物联网小镇公众号。

网站名称：代码安全性和健壮性：如何在if和assert中做选择?
文章位置：http://www.mswzjz.cn/qtweb/news35/486185.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

用户体验知识

同城分类信息

南充电信机房托管　　 　教育培训网站建设方案　　 　成都网站建设公司　　 　成都广告公司　　 　谷歌优化排名　　 　宏昇商务服务　　 　成都网站设计　　 　固迪佳新材料　　 　LED亮化工程　　 　网络推广外包　　 　资阳网站建设　　 　成都网站建设　　 　网站优化公司　　 　成都谷歌推广　　 　重庆网站建设　　 　名片印刷厂　　 　成都雨棚定制　　 　成都高电机柜租用　　 　宣威网站建设　　 　温岭熙道网站