C 语言编程 总结

判断失败而非成功

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

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

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

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

通过上述代码可以知道，更改后的代码消除了 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. {
5. return;
6. }
7. 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. {
4. return;
5. }
6. 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. {
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;
17. }

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

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

这样进行更改逻辑上是不存在问题了， 但是代码却变得不是那么直观了，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. {
9. if (_length < SESSION_ID_LEN_MIN || _length > SESSION_ID_LEN_MAX)
10. {
11. return ERROR;
12. }
13.  
14. memcpy (g_SessionId, session_id, _length);
15. g_SessionId [_length] = '\0';
16.  
17. return SUCESS;
18. }

通过上述的更改，也就是让 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. {
3. pthread_mutexattr attr;
4. queue *queue;
5.  
6. queue = (queue_t *)malloc(sizeof(queue_t));
7. if (0 == queue)
8. {
9. return -1;
10. }
11. *_pp_queue = queue;
12.  
13. memset (queue, 0, sizeof (*queue));
14. queue->size_ = _size;
15. pthread_mutexattr_init (&attr);
16. if (0 != pthread_mutex_init(&queue->mutex_, &attr))
17. {
18. pthread_mutexattr_destroy (&attr);
19. free (queue);
20. return -1;
21. }
22. queue->messages_ = (void**) malloc (queue->size_ * sizeof (void *));
23.  
24. if (0 == queue->messages_)
25. {
26. pthread_mutexattr_destroy (&attr);
27. free (queue);
28. return -1;
29. }
30. if (0 != sem_init(&queue->sem_put_, 0, queue->size))
31. {
32. free (queue->message_);
33. pthread_mutexattr_destroy (&attr);
34. free (queue);
35. return -1;
36. }
37. pthread_mutexattr_destroy (&attr);
38. return 0;
39. }

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

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

可以看到使用 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. {
9. g_aaa_eap_str_buff = (char **) malloc (MAX_NUM_PADIUS_IDS);
10. if (0 == g_aaa_eap_str_buff)
11. {
12. log_error ("Failed to allocate buffer for storing eap string");
13. return;
14. }
15.  
16. for (int i = 0; i < MAX_NUM_PADIUS_IDS; i++)
17. {
18. g_aaa_eap_str_buff [i] = (char *) malloc (MAX_EAP_MESSAGE_LEN);
19. if (0 == g_aaa_eap_str_buff [i])
20. {
21. log_error ("Failed to allocate buffer for storing eap string");
22. }
23. }
24.  
25. while (1)
26. {
27. ...
28. }
29. }

上述代码是通过 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. {
9. while (1)
10. {
11. ......
12. }
13. }

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