C++可变参数的另一种实现

大家熟知的C库函数printf函数就是一个可变参数函数，它是怎么实现的呢?不过他实现是有条件的，必须函数参数的入栈顺序为从右向左的顺序，也即函数的形参，在函数调用之前，必须是最右边的参数先入栈，并且参数都必须通过栈传递，以1个例子说明，如函数func(arg1, arg2,arg3),那么函数的堆栈应是：

ebp是帧指针寄存器，一般用来存取堆栈，有了堆栈结构，下面我们看看C可变参数的具体实现原理：

1. #include <stdio.h>
2. enum {
3. ptChar,
4. ptInt,
5. ptFloat,
6. ptDouble,
7. };
8. void printSum(unsigned long paramFormat, ...)
9. {
10. /*高16位为可变参数类型，低16位为可变参数个数*/
11. int paramType = (paramFormat >> 16);
12. int paramNum = paramFormat & 0xffff;
13. /*¶mFormat = ebp + 8,第一个参数的地址*/
14. unsigned long *pArg = ¶mFormat;
15. /*ebp + 0x0c, 第二个参数地址*/
16. pArg++;
17. switch(paramType)
18. {
19. case ptChar:
20. {
21. int sum = 0;
22. for (int i = 0; i < paramNum; i++)
23. {
24. char *pValue = (char *)pArg;
25. sum += *pValue;
26. pArg++;
27. }
28. printf("%d\n", sum);
29. }
30. break;
31. case ptInt:
32. {
33. int sum = 0;
34. for (int i = 0; i < paramNum; i++)
35. {
36. int *pValue = (int *)pArg;
37. sum += *pValue;
38. pArg++;
39. }
40. printf("%d\n", sum);
41. }
42. break;
43. case ptFloat:
44. {
45. float sum = 0;
46. /**/
47. pArg++;
48. /*浮点参数，堆栈占8个字节，所以指针偏移为8*/
49. for (int i = 0; i < paramNum; i++)
50. {
51. float *pValue = (float *)pArg;
52. sum += *pValue;
53. pArg++;
54. pArg++;
55. }
56. printf("%f\n", sum);
57. }
58. break;
59. case ptDouble:
60. {
61. double sum = 0;
62. /*双精度浮点参数，堆栈占8个字节，所以指针偏移为8*/
63. for (int i = 0; i < paramNum; i++)
64. {
65. double *pValue = (double *)pArg;
66. sum += *pValue;
67. pArg++;
68. pArg++;
69. }
70. printf("%f\n", sum);
71. }
72. break;
73. default:
74. printf("unknowned type!\n");
75. break;
76. }
77. }
78. void main()
79. {
80. unsigned long paramFormat = 3;
81. char a = 1, b = 2, c = 3;
82. printSum(paramFormat, a, b, c);
83. paramFormat = ptInt << 16;
84. paramFormat += 3;
85. int ia = 1, ib = 2, ic = 3;
86. printSum(paramFormat, ia, ib, ic);
87. paramFormat = ptFloat << 16;
88. paramFormat += 3;
89. float fa = 1, fb = 2, fc = 3;
90. printSum(paramFormat, fa, fb, fc);
91. paramFormat = ptDouble << 16;
92. paramFormat += 3;
93. double da = 1, db = 2, dc = 3;
94. printSum(paramFormat, da, db, dc);
95. }

上面这种方法对函数参数的入栈顺序有限制，必须从右向左入栈，这就是为什么pascal调用方式不能实现printf的原因，并且函数形参都要通过栈来传递，这对有些编译器为了优化处理，函数参数通过寄存器来传递，从而不满足要求。鉴于次，本文采用C++的默认形参实现可变参数的方法，没有上面的这些限制，下面是实现代码：

1. #include <stdio.h>
2. enum {
3. ptChar,
4. ptInt,
5. ptFloat,
6. ptDouble,
7. };
8. void printSum(unsigned long paramType,
9. void *arg1 = NULL,
10. void *arg2 = NULL,
11. void *arg3 = NULL,
12. void *arg4 = NULL,
13. void *arg5 = NULL,
14. void *arg6 = NULL,
15. void *arg7 = NULL,
16. void *arg8 = NULL,
17. void *arg9 = NULL,
18. void *arg10 = NULL)
19. {
20. void *arg[10] = {
21. arg1,
22. arg2,
23. arg3,
24. arg4,
25. arg5,
26. arg6,
27. arg7,
28. arg8,
29. arg9,
30. arg10,
31. };
32. switch(paramType)
33. {
34. case ptChar:
35. {
36. int sum = 0;
37. for (int i = 0; i < 10; i++)
38. {
39. if (arg[i] != NULL)
40. {
41. char *pValue = (char *)arg[i];
42. sum += *pValue;
43. }
44. else
45. break;
46. }
47. printf("%d\n", sum);
48. }
49. break;
50. case ptInt:
51. {
52. int sum = 0;
53. for (int i = 0; i < 10; i++)
54. {
55. if (arg[i] != NULL)
56. {
57. int *pValue = (int *)arg[i];
58. sum += *pValue;
59. }
60. else
61. break;
62. }
63. printf("%d\n", sum);
64. }
65. break;
66. case ptFloat:
67. {
68. float sum = 0;
69. for (int i = 0; i < 10; i++)
70. {
71. if (arg[i] != NULL)
72. {
73. float *pValue = (float *)arg[i];
74. sum += *pValue;
75. }
76. else
77. break;
78. }
79. printf("%f\n", sum);
80. }
81. break;
82. case ptDouble:
83. {
84. double sum = 0;
85. for (int i = 0; i < 10; i++)
86. {
87. if (arg[i] != NULL)
88. {
89. double *pValue = (double *)arg[i];
90. sum += *pValue;
91. }
92. else
93. break;
94. }
95. printf("%f\n", sum);
96. }
97. break;
98. default:
99. printf("unknowned type!\n");
100. break;
101. }
102. }
103. void main()
104. {
105. unsigned long paramType = ptChar;
106. char a = 1, b = 2, c = 3;
107. printSum(paramType, &a, &b, &c);
108. paramType = ptInt;
109. int ia = 1, ib = 2, ic = 3;
110. printSum(paramType, &ia, &ib, &ic);
111. paramType = ptFloat;
112. float fa = 1, fb = 2, fc = 3;
113. printSum(paramType, &fa, &fb, &fc);
114. paramType = ptDouble;
115. double da = 1, db = 2, dc = 3;
116. printSum(paramType, &da, &db, &dc);
117. }

http://blog.csdn.net/rabinsong/article/details/8946514