C语言学习中的变参处理

在C语言中，我们都知道给函数传参，有传址调用和传值调用的差别。但是，很少有书籍、文章专门论述到，C语言的函数传参，还有另外一大类应用，就是变参处理。举个例子，我们最常用的printf函数，就是典型的变参函数，它的参数不固定，可以使用格式化字符控制输出格式。这个大家可能都很熟悉。

变参函数用途很多，其通过设计，对外提供变参接口，允许上层业务层自由地通过格式化字符串来实现对自己输出行为的控制，这在很多debug和syslog日志输出场合很有用，我的书《0bug-C/C++商用工程之道》里面，第五章开篇就在讲这个设计方法。这也是几乎所有C底层库进行格式化输出的最基本手段。

关于如何使用C语言变参函数，实现有效的字符串格式化处理，我想大家可能很早就学会了，但是，近期几个朋友问我问题，我才发现，很多人还是不了解如何设计变参函数。正好，近期我优化我的工程库，特别重新设计的变参函数的处理方法。我这里就share一下，供大家参考。

还是那句话哈，一家之言，欢迎拍砖。

由于前期我很多博文，我的书《0bug-C/C++商用工程之道》，都大量讲过变参处理办法，我这里就不细讲了，大家有兴趣，可以看看我的SafePrintf这个函数，这在过去很多博文中都出现过了，呵呵，算是“代码明星”了。

Code:

1. int SafePrintf(char* szBuf,int nMaxLength,char *szFormat, ...)   
2. {   
3.     int nListCount=0;   
4.     va_list pArgList;   
5.   
6.     if (!szBuf) goto SafePrintf_END_PROCESS;   
7.     va_start (pArgList,szFormat);   
8.     nListCount+=Linux_Win_vsnprintf(szBuf+nListCount,   
9.         nMaxLength-nListCount,szFormat,pArgList);   
10.     va_end(pArgList);   
11.     if(nListCount>(nMaxLength-1)) nListCount=nMaxLength-1;   
12.     *(szBuf+nListCount)='\0';   
13.   
14. SafePrintf_END_PROCESS:   
15.     return nListCount;   
16. }  

不过，这里面有个潜在的问题，我一直没有解决好，就是说，虽然我提供了一个SafePrintf函数来处理变参，但如果另外一个函数，也提供变参界面，这时候，很不好把自己的变参参数传递给SafePrintf来处理。如下例：

Code:

1. void Func(char* szFormat,...)   
2. {   
3.     char szBuf[256];   
4.     SafePrintf(szBuf,256,...);    //???   
5. }   

这样直接传递...是肯定错误的，根据ANSI C99的定义，此时要传递变参，必须使用void va_copy(va_list dst, va_list src); 这个宏来处理，以va_list这种隐式数据结构的显式拷贝动作，来把Func这个函数的变参，传递给SafePrintf。并且，由va_copy初始化的va_list在使用结束时必须使用va_end来“释放”。

这显然太麻烦了，我以前就一直很抵制这种又是显式，又是隐式，变来变去的接口方式。所以，我在《0bug-C/C++商用工程之道》这本书的库代码中，一直是把中间处理变参这段代码拷来拷去使用，哪个函数处理变参，就在哪个函数一开始的地方，来上这么一段，把变参先处理成定参，再向下传递。

不过，这也有问题，我的习惯，同样逻辑的代码只写一次，以后都是调用，避免无谓的笔误和代码冗余。这显然不符合我的习惯，所以，我也一直在想怎么优化这一块。

近期我想了一下，决定采用函数型宏来处理这个问题，这虽然像inline一样，并不能真实地减少代码，但是，它使程序变得很简洁，程序员看起来清清爽爽，同时，由于函数型宏可以固化操作，不会再出现笔误问题，算是个比较好的折中方案。嗯，抵制使用宏的C++er们注意了哈，这是一个inline无法替代宏的实例了。呵呵。

当然，在讨论字符串处理的前面，首先要给大家一些include的头文件，以及一些基本的定义，我呢，懒得一一分辨了，就把《0bug-C/C++商用工程之道》的总跨平台include表列出来，大家直接用哈。当然，由于这些定义，下面的代码必然是跨平台的。

Code:

1. #include <stdio.h>   
2. #include <stdlib.h>   
3. #include <stdarg.h>   
4. #include <time.h>   
5. #include <fcntl.h>   
6. #include <signal.h>   
7.   
8. #ifdef WIN32   
9.     #include <conio.h>   
10.     #include <windows.h>   
11.     #include <process.h>   
12.     #include <winsock.h>   
13. #else // not WIN32    
14.     #include <unistd.h>   
15.     #include <errno.h>   
16.     #include <pthread.h>   
17.     #include <fcntl.h>   
18.     #include <unistd.h>    
19.     #include <netinet/in.h>   
20.     #include <string.h>   
21.     #include <sys/time.h>   
22.     #include <arpa/inet.h>   
23.     #include <errno.h>   
24.     #include <termios.h>   
25.     #include <netdb.h>   
26.     #include <getopt.h>   
27.     #include <netinet/in.h>   
28.     #include <arpa/inet.h>   
29.     #include <unistd.h>   
30. #endif   
31. ////////////////////////////////////////////////////////////////////  
32. #ifdef WIN32   
33.     #pragma warning (disable : 4800)   
34.     #pragma warning (disable : 4996)    
35.     #pragma warning (disable : 4200)   
36.     #pragma warning (disable : 4244)    
37.     #pragma warning (disable : 4010)   
38.     #define Linux_Win_vsnprintf _vsnprintf   
39. #else // not WIN32    
40.     #define Linux_Win_vsnprintf vsnprintf   
41. #endif   
42. #ifndef null    
43.     #define null 0   
44. #endif  

开始做事，我首先作了如下函数型宏代码：

Code:

1. #define TONY_FORMAT(nPrintLength,szBuf,nBufferSize,szFormat) \  
2. { \   
3.     va_list pArgList; \   
4.     va_start (pArgList,szFormat); \   
5.     nPrintLength+=Linux_Win_vsnprintf(szBuf+nPrintLength, \   
6.         nBufferSize-nPrintLength,szFormat,pArgList); \   
7.     va_end(pArgList); \   
8.     if(nPrintLength>(nBufferSize-1)) nPrintLength=nBufferSize-1; \   
9.     *(szBuf+nPrintLength)='\0'; \   
10. }  

这个宏有4个参数，我解释一下：

nPrintLength：这个很重要，C的规约，处理变参的函数一般要返回一个int，表示变参展开后，真实的字节数，注意，这里没有包括字符串这个'\0'的位宽，即仅仅是strlen的长度。很多时候，C语言程序员习惯于要采纳这个值参与后续计算，嗯，我们后面就有这个例子，所以，外部传进来一个变量nPrintLength，就是求这个值。

这也看出来，函数型宏，全部相当于传址调用，可以直接修改外部的变量的值的。

szBuf,nBufferSize：就是希望把变参展开，填充到的缓冲区和缓冲区长度，我强调0bug编程，很多时候，外部传入一个缓冲区要求函数填充的时候，都必须给一个边界，避免内存写出界导致崩溃，这个nBufferSize就是干这个的，内部的设计会保证不超过这个边界。

szFormat：精华了哈，前面说那么麻烦的va_list传递变参模式，在此简化为直接把szFormat传进来就好了。我认为这是这个设计最漂亮的一点，大大简化了调用者的程序行为，再也不麻烦了，呵呵。

ok，有了这个宏，我们来改写一下前面经典的SafePrintf看看：

Code:

1. //安全的变参打印函数   
2. inline int SafePrintf(char* szBuf,int nBufSize,char* szFormat, ...)   
3. {   
4.     if(!szBuf) return 0;   
5.     if(!nBufSize) return 0;   
6.     if(!szFormat) return 0;   
7.     int nRet=0;   
8.     TONY_FORMAT(nRet,szBuf,nBufSize,szFormat);   
9.     return nRet;   
10. }  

大家注意到什么没有？SafePrintf里面复杂的逻辑不见了，全部被整合成为TONY_FORMAT这个函数宏的调用。

嗯，考虑到很多时候，我们做Debug或者日志输出，需要打印的时候自动加上一个时间戳，因此，我又做了变参处理宏的时间戳版本： 

Code:

1. #define TONY_FORMAT_WITH_TIMESTAMP(nPrintLength,szBuf,nBufferSize,szFormat) \  
2. { \   
3.     time_t t; \   
4.     struct tm *pTM=NULL; \   
5.     time(&t); \   
6.     pTM = localtime(&t); \   
7.     nPrintLength+=SafePrintf(szBuf,nBufferSize,"[%s",asctime(pTM)); \   
8.     szBuf[nPrintLength-1]='\0'; \   
9.     nPrintLength--; \   
10.     nPrintLength+=SafePrintf(szBuf+nPrintLength,nBufferSize-nPrintLength,"] "); \   
11.     TONY_FORMAT(nPrintLength,szBuf,nBufferSize,szFormat); \   
12. }  

大家注意没，这里面，TONY_FORMAT_WITH_TIMESTAMP马上就在调用前面的SafePrintf，以及TONY_FORMAT。这是我做程序的习惯，每个模块写出来就是要给人用的，自己往往就是第一个用户，函数接口，api设计得好不好，自己一用就知道，不好用就调整，调整到自己爽为止。把自己站在用户的立场上，把程序调整到自己用起来都“爽”，你的程序就能获得用户的好评。

我一直说，“程序员的用户，不仅仅是终端用户，还包括和你自己一样的，甚至就是你自己，程序员。”就是这个意思，大家能理解吗？

这里面有个细节大家注意一下，asctime这个系统函数很讨厌，它格式化的字符串，最后自动带着一个回车，这会打乱我的输出顺序，所以我用了 szBuf[nPrintLength-1]='\0'; 这句话来回退，消灭这个多余的回车。

当然，有了这个时间戳宏，我们也可以很轻松写出SafePrintf的时间戳版本：

Code:

1. inline int SafePrintfWithTimestamp(char* szBuf,int nBufSize,char* szFormat, ...)   
2. {   
3.     if(!szBuf) return 0;   
4.     if(!nBufSize) return 0;   
5.     if(!szFormat) return 0;   
6.     int nRet=0;   
7.     TONY_FORMAT_WITH_TIMESTAMP(nRet,szBuf,nBufSize,szFormat);   
8.     return nRet;   
9. }  

还是要给个测试嘛：

Code:

1. inline void Test_TONY_FORMAT(void)   
2. {   
3.     char szBuf[256];   
4.     int nLength=0;   
5.     nLength=SafePrintf(szBuf,256,"Test: %d",100);   
6.     printf("[%d] %s\n",nLength,szBuf);   
7.     nLength=SafePrintfWithTimestamp(szBuf,256,"Test: %d",100);   
8.     printf("[%d] %s\n",nLength,szBuf);   
9. }   
10. 结果：   
11. [9] Test: 100   
12. [36] [Wed May 12 10:10:32 2010] Test: 100  

不过，为了仔细甄别，我还是单独写了两个变参处理函数来验证这个变参传递情况，第一个模拟printf，第二个模拟fprintf，大家可以看看代码。

这是printf版本：

Code:

1. #define TONY_LINE_MAX 1024      //最大一行输出的字符数  
2. //输出到控制台   
3. inline int TonyPrintf(bool bWithTimestamp,      //是否带时间戳标志  
4.                       char* szFormat, ...)      //格式化字符串  
5. {   
6.     if(!szFormat) return 0;   
7.     char szBuf[TONY_LINE_MAX];   
8.     int nLength=0;   
9.     if(!bWithTimestamp)            
10.     {   //注意，由于内部是函数型宏，if...else这个大括号必不可少   
11.         TONY_FORMAT(nLength,szBuf,TONY_LINE_MAX,szFormat);   
12.     }   //注意，由于内部是函数型宏，if...else这个大括号必不可少   
13.     else  
14.     {   //注意，由于内部是函数型宏，if...else这个大括号必不可少   
15.         TONY_FORMAT_WITH_TIMESTAMP(nLength,szBuf,TONY_LINE_MAX,szFormat);   
16.     }   //注意，由于内部是函数型宏，if...else这个大括号必不可少   
17.     return printf(szBuf);   
18. }   
19. inline void TestTonyPrintf(void)   
20. {   
21.     int i=0;   
22.     double dTest=123.456;   
23.     unsigned int unTest=0xAABBCC;   
24.     for(i='A';i<='E';i++)   
25.     {   
26.         TonyPrintf(0,"[%d]: %0.2f, %c, 0x%08X\n",i,dTest,i,unTest);   
27.     }   
28.     for(i='A';i<='E';i++)   
29.     {   
30.         TonyPrintf(1,"[%d]: %0.2f, %c, 0x%08X\n",i,dTest,i,unTest);   
31.     }   
32. }   
33. 运行结果：   
34. [65]: 123.46, A, 0x00AABBCC   
35. [66]: 123.46, B, 0x00AABBCC   
36. [67]: 123.46, C, 0x00AABBCC   
37. [68]: 123.46, D, 0x00AABBCC   
38. [69]: 123.46, E, 0x00AABBCC   
39. [Wed May 12 09:17:43 2010] [65]: 123.46, A, 0x00AABBCC   
40. [Wed May 12 09:17:43 2010] [66]: 123.46, B, 0x00AABBCC   
41. [Wed May 12 09:17:43 2010] [67]: 123.46, C, 0x00AABBCC   
42. [Wed May 12 09:17:43 2010] [68]: 123.46, D, 0x00AABBCC   
43. [Wed May 12 09:17:43 2010] [69]: 123.46, E, 0x00AABBCC   

fprintf版本比较麻烦一点，需要先创建一根文件指针。

Code:

1. //输出到文件   
2. inline int TonyFPrintf(FILE* fp,                //文件指针  
3.                        bool bWithTimestamp,     //是否带时间戳标志  
4.                       char* szFormat, ...)      //格式化字符串  
5. {   
6.     if(!fp) return 0;   
7.     if(!szFormat) return 0;   
8.     char szBuf[TONY_LINE_MAX];   
9.     int nLength=0;   
10.     if(!bWithTimestamp)   
11.     {   //注意，由于内部是函数型宏，if...else这个大括号必不可少  
12.         TONY_FORMAT(nLength,szBuf,TONY_LINE_MAX,szFormat);   
13.     }   //注意，由于内部是函数型宏，if...else这个大括号必不可少  
14.     else  
15.     {   //注意，由于内部是函数型宏，if...else这个大括号必不可少  
16.         TONY_FORMAT_WITH_TIMESTAMP(nLength,szBuf,TONY_LINE_MAX,szFormat);   
17.     }   //注意，由于内部是函数型宏，if...else这个大括号必不可少  
18.     return fprintf(fp,szBuf);   
19. }   
20. inline void TestTonyFPrintf(void)   
21. {   
22.     FILE* fp=null;   
23.     int i=0;   
24.     double dTest=123.456;   
25.     unsigned int unTest=0xAABBCC;   
26.     fp=fopen("test.txt","at");   
27.     if(fp)   
28.     {   
29.         for(i='A';i<='E';i++)   
30.         {   
31.             TonyFPrintf(fp,0,"[%d]: %0.2f, %c, 0x%08X\n",i,dTest,i,unTest);   
32.         }   
33.         for(i='A';i<='E';i++)   
34.         {   
35.             TonyFPrintf(fp,1,"[%d]: %0.2f, %c, 0x%08X\n",i,dTest,i,unTest);   
36.         }   
37.         fclose(fp);   
38.     }   
39. }  

这个函数运行完后，屏幕上没有，不过，磁盘上会出现一个文件，叫做test.txt，里面的内容和前面的一样。

经过这些测试，我认为这次改版基本上成功了，使用这几个变参处理宏，我可以大幅度缩减很多变参函数的书写长度，程序显得很清爽，且功能比较完备。

我的计划是，这些代码目前先自己用，等用个一年半载，稳定性差不多了，在《0bug-C/C++商用工程之道》的第二版中，我会应用到新的工程库中去，供各位读者使用哈。

上述代码在VS2008下测试通过，不过，我的理解是跨平台的，由于全部是C的函数，处理的都是函数内部私有变量，因此，也是线程安全的。

大家看看，有问题再问哈。

 

 链接地址：http://tonyxiaohome.blog.51cto.com/925273/314371