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

时间：2023-03-08 17:09:55

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

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

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

相关文章