c语言变长参数

参考文章：点击打开链接

点击打开链接

http://blog.youkuaiyun.com/anye3000/article/details/6593551

http://blog.chinaunix.net/uid-7283526-id-2198861.html

printf函数原型：

#include <libioP.h>
#include <stdarg.h>
#include <stdio.h>
 
#undef printf
 
/* Write formatted output to stdout from the format string FORMAT.  */
/* VARARGS1 */
int
__printf (const char *format, ...)
{
  va_list arg;
  int done;
 
  va_start (arg, format);
  done = vfprintf (stdout, format, arg);
  va_end (arg);
 
  return done;
}

vsprintf函数原型：

int vsprintf(char *buf, const char *fmt, va_list args)
{
  int len;
  unsigned long num;
  int i, base;
  char *str;
  char *s;
 
  int flags;            // Flags to number()
 
  int field_width;    // Width of output field
  int precision;    // Min. # of digits for integers; max number of chars for from string
  int qualifier;    // 'h', 'l', or 'L' for integer fields
 
  for (str = buf; *fmt; fmt++)
  {
    if (*fmt != '%')
    {
      *str++ = *fmt;
      continue;
    }
           
    // Process flags
    flags = 0;
repeat:
    fmt++; // This also skips first '%'
    switch (*fmt)
    {
      case '-': flags |= LEFT; goto repeat;
      case '+': flags |= PLUS; goto repeat;
      case ' ': flags |= SPACE; goto repeat;
      case '#': flags |= SPECIAL; goto repeat;
      case '0': flags |= ZEROPAD; goto repeat;
    }
       
    // Get field width
    field_width = -1;
    if (is_digit(*fmt))
      field_width = skip_atoi(&fmt);
    else if (*fmt == '*')
    {
      fmt++;
      field_width = va_arg(args, int);
      if (field_width < 0)
      {
    field_width = -field_width;
    flags |= LEFT;
      }
    }
 
    // Get the precision
    precision = -1;
    if (*fmt == '.')
    {
      ++fmt;   
      if (is_digit(*fmt))
        precision = skip_atoi(&fmt);
      else if (*fmt == '*')
      {
        ++fmt;
        precision = va_arg(args, int);
      }
      if (precision < 0) precision = 0;
    }
 
    // Get the conversion qualifier
    qualifier = -1;
    if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L')
    {
      qualifier = *fmt;
      fmt++;
    }
 
    // Default base
    base = 10;
 
    switch (*fmt)
    {
      case 'c':
    if (!(flags & LEFT)) while (--field_width > 0) *str++ = ' ';
    *str++ = (unsigned char) va_arg(args, int);
    while (--field_width > 0) *str++ = ' ';
    continue;
 
      case 's':
    s = va_arg(args, char *);
    if (!s)    s = "<NULL>";
    len = strnlen(s, precision);
    if (!(flags & LEFT)) while (len < field_width--) *str++ = ' ';
    for (i = 0; i < len; ++i) *str++ = *s++;
    while (len < field_width--) *str++ = ' ';
    continue;
 
      case 'p':
    if (field_width == -1)
    {
      field_width = 2 * sizeof(void *);
      flags |= ZEROPAD;
    }
    str = number(str, (unsigned long) va_arg(args, void *), 16, field_width, precision, flags);
    continue;
 
      case 'n':
    if (qualifier == 'l')
    {
      long *ip = va_arg(args, long *);
      *ip = (str - buf);
    }
    else
    {
      int *ip = va_arg(args, int *);
      *ip = (str - buf);
    }
    continue;
 
      case 'A':
    flags |= LARGE;
 
      case 'a':
    if (qualifier == 'l')
      str = eaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
    else
      str = iaddr(str, va_arg(args, unsigned char *), field_width, precision, flags);
    continue;
 
      // Integer number formats - set up the flags and "break"
      case 'o':
    base = 8;
    break;
 
      case 'X':
    flags |= LARGE;
 
      case 'x':
    base = 16;
    break;
 
      case 'd':
      case 'i':
    flags |= SIGN;
 
      case 'u':
    break;
 
      case 'E':
      case 'G':
      case 'e':
      case 'f':
      case 'g':
        str = flt(str, va_arg(args, double), field_width, precision, *fmt, flags | SIGN);
    continue;
 
      default:
    if (*fmt != '%') *str++ = '%';
    if (*fmt)
      *str++ = *fmt;
    else
      --fmt;
    continue;
    }
 
    if (qualifier == 'l')
      num = va_arg(args, unsigned long);
    else if (qualifier == 'h')
    {
      if (flags & SIGN)
    num = va_arg(args, short);
      else
    num = va_arg(args, unsigned short);
    }
    else if (flags & SIGN)
      num = va_arg(args, int);
    else
      num = va_arg(args, unsigned int);
 
    str = number(str, num, base, field_width, precision, flags);
  }
 
  *str = '\0';
  return str - buf;
}

stdarg.sh中那几个宏的原型：

1） va_list型变量：

#ifdef  _M_ALPHA
typedef struct {
        char *a0;       /* pointer to first homed integer argument */
        int offset;     /* byte offset of next parameter */
} va_list;
#else
typedef char *  va_list;
#endif

2）_INTSIZEOF 宏，获取类型占用的空间长度，最小占用长度为int的整数倍：

#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

3）VA_START宏，获取可变参数列表的第一个参数的地址（ap是类型为va_list的指针，v是可变参数最左边的参数）：

#define va_start(ap,v)  ( ap = (va_list)&v + _INTSIZEOF(v) )

4）VA_ARG宏，获取可变参数的当前参数，返回指定类型并将指针指向下一参数（t参数描述了当前参数的类型）：

#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

5）VA_END宏，清空va_list可变参数列表：

#define va_end(ap)      ( ap = (va_list)0 )

-------------------------------------------------------------------------------

几点说明:

_INTSIZEOF 宏，获取类型占用的空间长度，最小占用长度为int的整数倍,这句话蛮重要的

vsprintf函数的原型比较复杂，以后有时间再研究，现在会使用就行了，一个简单的实现：

#include <iostream>
#include <stdarg.h>
#include <cstdio>
using namespace std;
int myprintf(char * format,...)
{
    int nRet;
    va_list ap;
    va_start(ap,format);
    char sBuf[256]={0};
    nRet=vsprintf(sBuf,format,ap);
    puts(sBuf);
    va_end(ap);
    return nRet;
}
int main()
{
    //cout << "Hello world!" << endl;

    int n=myprintf("this is a test programming,and int :%d, double :%.2f, char :%s",14,56.23,"hehe");
    cout << "string len :" << n << endl;
    return 0;
}