从printf谈可变参数函数的实现

• 文章概要：
• 一直以来都觉得printf似乎是c语言库中功能最强大的函数之一，不仅因为它能格式化输出，更在于它的参数个数没有限制，要几个就给几个，来者不拒。printf这种对参数个数和参数类型的强大适应性，让人产生了对它进行探索的浓厚兴趣。

• 1. 使用情形

  1. int a =10;

  2. double b = 20.0;

  3. char *str = "Hello world";

  4. printf("begin print\n");

  5. printf("a=%d, b=%.3f, str=%s\n", a, b, str);

  6. ...

  从printf的使用情况来看，我们不难发现一个规律，就是无论其可变的参数有多少个，printf的第一个参数总是一个字符串。而正是这第一个参数，使得它可以确认后面还有有多少个参数尾随。而尾随的每个参数占用的栈空间大小又是通过第一个格式字符串确定的。然而printf到底是怎样取第一个参数后面的参数值的呢，请看如下代码

  2. printf 函数的实现

  01. //acenv.h

  02. typedef char *va_list;

  03.  

  04. #define  _AUPBND        (sizeof (acpi_native_int) - 1)

  05. #define  _ADNBND        (sizeof (acpi_native_int) - 1)

  06.  

  07. #define _bnd(X, bnd)    (((sizeof (X)) + (bnd)) & (~(bnd)))

  08. #define va_arg(ap, T)   (*(T *)(((ap) += (_bnd (T, _AUPBND))) - (_bnd (T,_ADNBND))))

  09. #define va_end(ap)      (void) 0

  10. #define va_start(ap, A) (void) ((ap) = (((char *) &(A)) + (_bnd (A,_AUPBND))))

  11.  

  12. //start.c

  13. static char sprint_buf[1024];

  14. int printf(char *fmt, ...)

  15. {

  16. va_list args;

  17. int n;

  18. va_start(args, fmt);

  19. n = vsprintf(sprint_buf, fmt, args);

  20. va_end(args);

  21. write(stdout, sprint_buf, n);

  22. return n;

  23. }

  24.  

  25. //unistd.h

  26. static inline long write(int fd, const char *buf, off_t count)

  27. {

  28. return sys_write(fd, buf, count);

  29. }

  3. 分析

  从上面的代码来看，printf似乎并不复杂，它通过一个宏va_start把所有的可变参数放到了由args指向的一块内存中，然后再调用vsprintf. 真正的参数个数以及格式的确定是在vsprintf搞定的了。由于vsprintf的代码比较复杂，也不是我们这里要讨论的重点，所以下面就不再列出了。我们这里要讨论的重点是va_start(ap, A)宏的实现，它对定位从参数A后面的参数有重大的制导意义。现在把 #define va_start(ap, A) (void) ((ap) = (((char *) &(A)) + (_bnd (A,_AUPBND)))) 的含义解释一下如下：

  1. va_start(ap, A)

  2. {

  3. char *ap =  ((char *)(&A)) + sizeof(A)并int类型大小地址对齐

  4. }

  在printf的va_start(args, fmt)中，fmt的类型为char *, 因此对于一个32为系统 sizeof(char *) = 4, 如果int大小也是32，则va_start(args, fmt);相当于 char *args = (char *)(&fmt) + 4; 此时args的值正好为fmt后第一个参数的地址。对于如下的可变参数函数

  1. void fun(double d,...)

  2. {

  3. va_list args;

  4. int n;

  5. va_start(args, d);

  6. }

  则 va_start(args, d);相当于

  1. char *args = (char *)&d + sizeof(double);

  此时args正好指向d后面的第一个参数。

  可变参数函数的实现与函数调用的栈结构有关，正常情况下c/c++的函数参数入栈规则为__stdcall, 它是从右到左的，即函数中的最右边的参数最先入栈。对于函数

  1. void fun(int a, int b, int c)

  2. {

  3. int d;

  4. ...

  5. }

  其栈结构为

  1. 0x1ffc-->d

  2. 0x2000-->a

  3. 0x2004-->b

  4. 0x2008-->c

  对于任何编译器，每个栈单元的大小都是sizeof(int), 而函数的每个参数都至少要占一个栈单元大小，如函数 void fun1(char a, int b, double c, short d) 对一个32的系统其栈的结构就是

  1. 0x1ffc-->a  (4字节)

  2. 0x2000-->b  (4字节)

  3. 0x2004-->c  (8字节)

  4. 0x200c-->d  (4字节)

  对于函数void fun1(char a, int b, double c, short d)

  如果知道了参数a的地址，则要取后续参数的值则可以通过a的地址计算a后面参数的地址，然后取对应的值，而后面参数的个数可以直接由变量a指定，当然也可以像printf一样根据第一个参数中的%模式个数来决定后续参数的个数和类型。如果参数的个数由第一个参数a直接决定，则后续参数的类型如果没有变化并且是已知的，则我们可以这样来取后续参数, 假定后续参数的类型都是double;

  1. void fun1(int num, ...)

  2. {

  3. double *p = (double *)((&num)+1);

  4. double Param1 = *p;

  5. double Param2 = *(p+1);

  6. ...

  7. double Paramn  *(p+num);

  8. }

  如果后续参数的类型是变化而且是未知的，则必须通过一个参数中设定模式来匹配后续参数的个数和类型，就像printf一样，当然我们可以定义自己的模式，如可以用i表示int参数，d表示double参数，为了简单，我们用一个字符表示一个参数，并由该字符的名称决定参数的类型而字符的出现的顺序也表示后续参数的顺序。 我们可以这样定义字符和参数类型的映射表，

  1. i---int

  2. s---signed short

  3. l---long

  4. c---char

  "ild"模式用于表示后续有三个参数，按顺序分别为int, long, double类型的三个参数那么这样我们可以定义自己版本的printf 如下

  01. void printf(char *fmt, ...)

  02. {

  03. char s[80] = "";

  04. int paramCount = strlen(fmt);

  05. write(stdout, "paramCount = " , strlen(paramCount = ));

  06. itoa(paramCount,s,10);

  07. write(stdout, s, strlen(s));

  08. char *p = (char *)(&fmt) + sizeof(char *);

  09. int *pi = (int *)p;

  10. for (int i=0; i<paramCount; i++)

  11. {

  12. char line[80] = "";

  13. strcpy(line, "param");

  14. itoa(i+1, s, 10);

  15. strcat(line, s);

  16. strcat(line, "=");

  17. switch(fmt[i])

  18. {

  19. case 'i':

  20. case 's':

  21. itoa((*pi),s,10);

  22. strcat(line, s);

  23. pi++;

  24. break;

  25. case 'c':

  26. {

  27. int len = strlen(line);

  28. line[len] = (char)(*pi);

  29. line[len+1] = '\0';

  30. }

  31. break;

  32. case 'l':

  33. ltoa((*(long *)pi),s,10);

  34. strcat(line, s);

  35. pi++;

  36. break;

  37. default:

  38. break;

  39. }

  40. }

  41. }

  也可以这样定义我们的Max函数，它返回多个输入整型参数的最大值

  01. int Max(int n, ...)

  02. {

  03. int *p = &n + 1;

  04. int ret = *p;

  05. for (int i=0; i<n; i++)

  06. {

  07. if (ret < *(p + i))

  08. ret = *(p + i);

  09. }

  10. return ret;

  11. }

  可以这样调用, 后续参数的个数由第一个参数指定

  1. int m = Max(3, 45, 12, 56);

  2. int m = Max(1, 3);

  3. int m = Max(2, 23, 45);

  4.  

  5. int first = 34, second = 45, third=5;

  6. int m = Max(5, first, second, third, 100, 4);

  结论

  对于可变参数函数的调用有一点需要注意，实际的可变参数的个数必须比前面模式指定的个数要多，或者不小于， 也即后续参数多一点不要紧，但不能少， 如果少了则会访问到函数参数以外的堆栈区域，这可能会把程序搞崩掉。前面模式的类型和后面实际参数的类型不匹配也有可能造成把程序搞崩溃，只要模式指定的数据长度大于后续参数长度，则这种情况就会发生。如：

  1. printf("%.3f, %.3f, %.6e", 1, 2, 3, 4);

  参数1，2，3，4的默认类型为整型，而模式指定的需要为double型，其数据长度比int大，这种情况就有可能访问函数参数堆栈以外的区域，从而造成危险。但是printf("%d, %d, %d", 1.0, 20., 3.0);这种情况虽然结果可能不正确，但是确不会造成灾难性后果。因为实际指定的参数长度比要求的参数长度长，堆栈不会越界。