Windows下C/C++可变参数宏实现技巧

Windows下C/C++可变参数宏实现技巧

在开发过程当中，有不少阶段，每一个阶段可能会注重不一样的重点，咱们可能会在不一样阶段让程序输出或者打印不一样的信息以反应运行的状况，因此咱们必须分阶段的使得程序输出咱们在每一个阶段所要关心的信息，甚至在最后让程序再也不输出信息。这就要用到了宏定义！

      咱们知道，在linux下很方便的就能实现可变参数宏的定义，

好比：

#define myprint(fmt, a...)    printf("%s,%s(),%d:" fmt "/n", __FILE__,__FUNCTION__,__LINE__, ##a)就定义了本身的输出宏，当没必要再输出这些多是调式，跟踪，断言，日志...的信息时，能够再定义宏为空：

#define myprintf(fmt,a...)

这样，从新编译后，这些宏引用的地方将所有没有语句，从而省去这些开销。

可是，在windows下，通常咱们采用的VC6.0,VS2003,VS2005,VS2008(待定)编辑器中自带的C/C++编译器并不支持变参宏的定义，gcc编译器支持，听说最新版本的C99也支持。

能够在windows下这样定义宏：

#define myprint printf

但 是，当后期不想再要宏输出了，只能定义 #define myprint为空，在那些有宏调用的代码区会留下相似 ("DEBUG:>> %d,%s,%f",idx,"weide001",99.001);这样的语句，它应该会被程序运算一次，应该会像函数参数那样被压栈，出栈一次，从而 增长了程序的运行开销，不是一个上策。

因此，在windows下须要变通一下，如下四种方式能够做为从此windows下定义可变参宏定义的参考：

      （1）引用系统变参函数：

#include <stdarg.h>

 

#ifdef _WIN32

  #define vsnprinf _vsnprintf

  #define vsprinf  _vsprintf

#endif

 

int my_print(const char* file,cosnt char* fun,const char* line,const char *fmt, ...)

{

  int t = 0;

  char out[1024]="";

  va_list ap;

 

  /*
  Test Env:
    gcc version 3.4.5 20051201 (Red Hat 3.4.5-2)
  Result:
  使用vsprintf时：
    当fmt的长度大于1024时出现: 段错误
    当fmt的长度小于1024时出现: 正常
  使用vsnprintf时：
    当fmt的长度大于1024时出现: 多余的字符不保存到out中
    当fmt的长度小于1024时出现: 正常
  vsnprintf的返回值同snprintf很类似

  ---------------------------------------------------
  Test Env:
    Microsoft Windows XP [版本 5.1.2600]
    Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 12.00.8168 for 80x86
  Result:
  使用_vsprintf时：
    当fmt的长度大于1024时出现: 段错误
    当fmt的长度小于1024时出现: 正常
  使用_vsnprintf时：
    当fmt的长度大于1024时出现: 多余的字符不保存到out中
    当fmt的长度小于1024时出现: 正常
  _vsnprintf的返回值同_snprintf很类似
   */

  va_start(ap, fmt);

  t = vsnprintf(out, 1024, fmt, ap);

  va_end(ap);

 

  printf("%s,%s(),%d: %s/n", file,fun,line,out);

 

  return (t);

}

 

#define myprint(str)  my_print(__FILE__,__FUNCTION__,__LINE__,str)

只能输出一个字符串参数。啥也别说了，这个确定很烂，这里主要是记住这个变参函数的实现方式。

 

（2）新的C99规范支持了可变参数的宏，具体使用以下：

#include   <stdarg.h>

 

#define   myprint(fmt, ...)   printf(fmt,__VA_ARGS__)  

 

（3）这个很雷人：(用‘_’来代替‘,’，不然报错或者警告实参太多或者实参个数不一致)

#define   _   , 

#define   mysprintf(geter, fmt, args)   sprintf(geter, fmt, args)  

 

{

   char str[128] = "";

   mysprintf(str, "name=%s age=%d weight=%f" _ "weide001" _ 23 _ 57.9);//调用很累，和以往的方式出入太大

}

 

（4）使用##：

#define   mysprintf(geter)   sprintf##geter 

 

{

  char str[128] = "";

  mysprintf(  (str,"name=%s age=%d weight=%f","weide001",23,57.9)  );//也有点雷人，调用时多出来了一层括弧

}

 

可变参数的宏里的 ## 做用

GCC始终支持复杂的宏，它使用一种不一样的语法从而可使你能够给可变参数一个名字，如同其它参数同样。例以下面的例子：

#define debug(format, args...) fprintf (stderr, format, args)

可是在debug可变参数为0的时候，debug("hello /n")，编译会出错，采用这样的方式：

#define debug(format, ...) fprintf (stderr, format, ##args)就能够

##的用法，文中是这样解释的：“这里，假如可变参数被忽略或为空，‘##’操做将使预处理器（preprocessor）去除掉它前面的那个逗号。””这句话不明白，是##的新功能，仍是原有链接的功能的应用？

其实，## 是粘连符

好比windows里 #define __T（text） L##text

就是在text前面加上了一个L

__T("abc")就成了 L"abc"

 

可变参数及可变参数宏的使用

咱们在C语言编程中会遇到一些参数个数可变的函数,例如printf()这个函数,这里将介绍可变函数的写法以及原理.

 

* 1. 可变参数的宏

通常在调试打印Debug 信息的时候, 须要可变参数的宏. 从C99开始可使编译器标准支持可变参数宏(variadic macros), 另外GCC 也支持可变参数宏, 可是两种在细节上可能存在区别.

 

1. __VA_ARGS__

__VA_ARGS__ 将"..." 传递给宏.如
#define debug(format, ...) fprintf(stderr, fmt, __VA_ARGS__)

在GCC中也支持这类表示, 可是在G++ 中不支持这个表示.

 

2. GCC 的复杂宏

GCC使用一种不一样的语法从而可使你能够给可变参数一个名字，如同其它参数同样。

#define debug(format, args...) fprintf (stderr, format, args)

这和上面举的那个定义的宏例子是彻底同样的，可是这么写可读性更强而且更容易进行描述。

 

3. ##__VA_ARGS__

上面两个定义的宏, 若是出现debug("A Message") 的时候, 因为宏展开后有个多余的逗号, 因此将致使编译错误. 为了解决这个问题，CPP使用一个特殊的‘##’操做。

#define debug(format, ...) fprintf (stderr, format, ## __VA_ARGS__)

这里，若是可变参数被忽略或为空，‘##’操做将使预处理器（preprocessor）去除掉它前面的那个逗号。若是你在宏调用时，确实提供了一些可变参数，GNU CPP也会工做正常，它会把这些可变参数放到逗号的后面。

 

4. 其余方法

一种流行的技巧是用一个单独的用括弧括起来的的 "参数" 定义和调用宏, 参数在宏扩展的时候成为相似 printf() 那样的函数的整个参数列表。

#define DEBUG(args) (printf("DEBUG: "), printf(args))

 

* 2. 可变参数的函数

写可变参数的C函数要在程序中用到如下这些宏:
void va_start( va_list arg_ptr, prev_param )
type va_arg( va_list arg_ptr, type )
void va_end( va_list arg_ptr )

va在这里是variable-argument(可变参数)的意思,这些宏定义在stdarg.h中.下面咱们写一个简单的可变参数的函数,该函数至少有一个整数参数,第二个参数也是整数,是可选的.函数只是打印这两个参数的值.
void simple_va_fun(int i, ...)
{
   va_list arg_ptr;
   int j=0;
  
   va_start(arg_ptr, i);
   j=va_arg(arg_ptr, int);
   va_end(arg_ptr);
   printf("%d %d/n", i, j);
   return;
}

在程序中能够这样调用:
simple_va_fun(100);
simple_va_fun(100,200);

从这个函数的实现能够看到,使用可变参数应该有如下步骤:
1)首先在函数里定义一个va_list型的变量,这里是arg_ptr,这个变量是指向参数的指针.
2)而后用va_start宏初始化变量arg_ptr,这个宏的第二个参数是第一个可变参数的前一个参数,是一个固定的参数.
3)而后用va_arg返回可变的参数,并赋值给整数j. va_arg的第二个参数是你要返回的参数的类型,这里是int型.
4)最后用va_end宏结束可变参数的获取.而后你就能够在函数里使用第二个参数了.若是函数有多个可变参数的,依次调用va_arg获取各个参数.

若是咱们用下面三种方法调用的话,都是合法的,但结果却不同:
1)simple_va_fun(100);
结果是:100 -123456789(会变的值)
2)simple_va_fun(100,200);
结果是:100 200
3)simple_va_fun(100,200,300);
结果是:100 200

咱们看到第一种调用有错误,第二种调用正确,第三种调用尽管结果正确,但和咱们函数最初的设计有冲突.下面一节咱们探讨出现这些结果的缘由和可变参数在编译器中是如何处理的.
* 3. 可变参数函数原理

va_start,va_arg,va_end是在stdarg.h中被定义成宏的,因为硬件平台的不一样,编译器的不一样,因此定义的宏也有所不一样,下面以VC++中stdarg.h里x86平台的宏定义摘录以下:

typedef char * va_list;
#define _INTSIZEOF(n) ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) )
#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap) ( ap = (va_list)0 )

定义_INTSIZEOF(n)主要是为了内存对齐,C语言的函数是从右向左压入堆栈的(设数据进栈方向为从高地址向低地址发展,即首先压入的数据在高地址). 下图是函数的参数在堆栈中的分布位置:

低地址       |-----------------------------|<-- &v

                          |第n-1个参数(最后一个固定参数)|

                          |-----------------------------|<--va_start后ap指向

                          |第n个参数(第一个可变参数) |

                          |-----------------------------|

                          |....... |

                          |-----------------------------|
                          |函数返回地址 |

高地址      |-----------------------------|

1. va_list 被定义为char *
2. va_start 将地址ap定义为 &v+_INTSIZEOF(v),而&v是固定参数在堆栈的地址,因此va_start(ap, v)之后,ap指向第一个可变参数在堆栈的地址
3. va_arg 取得类型t的可变参数值,以int型为例,va_arg取int型的返回值:
   j= ( *(int*)((ap += _INTSIZEOF(int))-_INTSIZEOF(int)) );
4. va_end 使ap再也不指向堆栈,而是跟NULL同样.这样编译器不会为va_end产生代码.

在不一样的操做系统和硬件平台的定义有些不一样,但原理倒是类似的.

* 4. 小结

对于可变参数的函数,由于va_start, va_arg, va_end等定义成宏,因此它显得很愚蠢,可变参数的类型和个数须要在该函数中由程序代码控制;另外,编译器对可变参数的函数的原型检查不够严格,对编程查错不利.
因此咱们写一个可变函数的C函数时,有利也有弊,因此在没必要要的场合,无需用到可变参数.若是在C++里,咱们应该利用C++的多态性来实现可变参数的功能,尽可能避免用C语言的方式来实现.

* 5. 附一些代码

#define debug(format, ...) fprintf(stderr, fmt, __VA_ARGS__)
#define debug(format, args...) fprintf (stderr, format, args)
#define debug(format, ...) fprintf (stderr, format, ## __VA_ARGS__)

// 使用va... 实现
void debug(const char *fmt, ...) {     int nBuf;     char szBuffer[1024];     va_list args;     va_start(args, fmt);     nBuf = vsprintf(szBuffer, fmt, args) ;     assert(nBuf >= 0);     printf("QDOGC ERROR:%s/n",szBuffer);     va_end(args); }