C語言中可變參數函數實現原理

C函數調用的棧結構

 可變參數函數的實現與函數調用的棧結構密切相關，正常狀況下C的函數參數入棧規則爲__stdcall, 它是從右到左的，即函數中的最右邊的參數最早入棧。例如，對於函數：

  void fun(int a, int b, int c)
  {
        int d;
        ...
  }

其棧結構爲

    0x1ffc-->d

    0x2000-->a

    0x2004-->b

    0x2008-->c

對於在32位系統的多數編譯器，每一個棧單元的大小都是sizeof(int), 而函數的每一個參數都至少要佔一個棧單元大小，如函數 void fun1(char a, int b, double c, short d) 對一個32的系統其棧的結構就是

    0x1ffc-->a  (4字節)（爲了字對齊）

    0x2000-->b  (4字節)

    0x2004-->c  (8字節)

    0x200c-->d  (4字節)

所以，函數的全部參數是存儲在線性連續的棧空間中的，基於這種存儲結構，這樣就能夠從可變參數函數中必須有的第一個普通參數來尋址後續的全部可變參數的類型及其值。

先看看固定參數列表函數：

void fixed_args_func(int a, double b, char *c)
{
        printf("a = 0x%p\n", &a);
        printf("b = 0x%p\n", &b);
        printf("c = 0x%p\n", &c);
}

對於固定參數列表的函數，每一個參數的名稱、類型都是直接可見的，他們的地址也都是能夠直接獲得的，好比：經過&a咱們能夠獲得a的地址，並經過函數原型聲明瞭解到a是int類型的。

   可是對於變長參數的函數，咱們就沒有這麼順利了。還好，按照C標準的說明，支持變長參數的函數在原型聲明中，必須有至少一個最左固定參數(這一點與傳統C有區別，傳統C容許不帶任何固定參數的純變長參數函數)，這樣咱們能夠獲得其中固定參數的地址，可是依然沒法從聲明中獲得其餘變長參數的地址，好比：

void var_args_func(const char * fmt, ...) 
{
    ... ... 
}

這裏咱們只能獲得fmt這固定參數的地址，僅從函數原型咱們是沒法肯定"..."中有幾個參數、參數都是什麼類型的。回想一下函數傳參的過程，不管"..."中有多少個參數、每一個參數是什麼類型的，它們都和固定參數的傳參過程是同樣的，簡單來說都是棧操做，而棧這個東西對咱們是開放的。這樣一來，一旦咱們知道某函數幀的棧上的一個固定參數的位置，咱們徹底有可能推導出其餘變長參數的位置。

咱們先用上面的那個fixed_args_func函數肯定一下入棧順序。

int main() 
{
    fixed_args_func(17, 5.40, "hello world");
    return 0;
}
a = 0x0022FF50
b = 0x0022FF54
c = 0x0022FF5C

從這個結果來看，顯然參數是從右到左，逐一壓入棧中的(棧的延伸方向是從高地址到低地址，棧底的佔領着最高內存地址，先入棧的參數，其地理位置也就最高了)。

咱們基本能夠得出這樣一個結論：

 c.addr = b.addr + x_sizeof(b);  /*注意:  x_sizeof !=sizeof */
 b.addr = a.addr + x_sizeof(a);

有了以上的"等式"，咱們彷佛能夠推導出 void var_args_func(const char * fmt, ... ) 函數中，可變參數的位置了。起碼第一個可變參數的位置應該是：first_vararg.addr = fmt.addr + x_sizeof(fmt);  根據這一結論咱們試着實現一個支持可變參數的函數：

#include <stdarg.h>
#include <stdio.h>

void var_args_func(const char * fmt, ...) 
{
    char    *ap;

    ap = ((char*)&fmt) + sizeof(fmt);
    printf("%d\n", *(int*)ap);  
        
    ap =  ap + sizeof(int);
    printf("%d\n", *(int*)ap);

    ap =  ap + sizeof(int);
    printf("%s\n", *((char**)ap));
}

int main()
{
    var_args_func("%d %d %s\n", 4, 5, "hello world");
　　 return 0;
}

期待輸出結果:
4
5
hello world

---

  先來解釋一下這個程序。咱們用ap獲取第一個變參的地址，咱們知道第一個變參是4，一個int 型，因此咱們用(int*)ap以告訴編譯器，以ap爲首地址的那塊內存咱們要將之視爲一個整型來使用，*(int*)ap得到該參數的值；接下來的變參是5，又一個int型，其地址是ap + sizeof(第一個變參)，也就是ap + sizeof(int)，一樣咱們使用*(int*)ap得到該參數的值；最後的一個參數是一個字符串，也就是char*，與前兩個int型參數不一樣的是，通過ap + sizeof(int)後，ap指向棧上一個char*類型的內存塊(咱們暫且稱之tmp_ptr, char *tmp_ptr)的首地址，即ap -> &tmp_ptr，而咱們要輸出的不是printf("%s\n", ap)，而是printf("%s\n", tmp_ptr); printf("%s\n", ap)是意圖將ap所指的內存塊做爲字符串輸出了，可是ap -> &tmp_ptr，tmp_ptr所佔據的4個字節顯然不是字符串，而是一個地址。如何讓&tmp_ptr是char **類型的，我們將ap進行強制轉換(char**)ap <=> &tmp_ptr，這樣咱們訪問tmp_ptr只須要在(char**)ap前面加上一個*便可，即printf("%s\n",  *(char**)ap);

---

   一切彷佛很完美，編譯也很順利經過，但運行上面的代碼後，不但得不到預期的結果，反而整個編譯器會強行關閉（你們能夠嘗試着運行一下），原來是ap指針在後來並無按照預期的要求指向第二個變參數，即並無指向5所在的首地址，而是指向了未知內存區域，因此編譯器會強行關閉。其實錯誤開始於：ap =  ap + sizeof(int);因爲內存對齊，編譯器在棧上壓入參數時，不是一個緊挨着另外一個的，編譯器會根據變參的類型將其放到知足類型對齊的地址上的，這樣棧上參數之間實際上可能會是有空隙的。（C語言內存對齊詳解（1） C語言內存對齊詳解（2） C語言內存對齊詳解（3））因此此時的ap計算應該改成：ap =  (char *)ap +sizeof(int) + __va_rounded_size(int);

改正後的代碼以下：

#include<stdio.h>

#define __va_rounded_size(TYPE)  \
  (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))

void var_args_func(const char * fmt, ...) 
{
    char *ap;

    ap = ((char*)&fmt) + sizeof(fmt);
    printf("%d\n", *(int*)ap);  
        
    ap = (char *)ap + sizeof(int) + __va_rounded_size(int);
    printf("%d\n", *(int*)ap);

    ap = ap + sizeof(int) + __va_rounded_size(int);
    printf("%s\n", *((char**)ap));
}

int main()
{
    var_args_func("%d %d %s\n", 4, 5, "hello world");　
    return 0;
}

var_args_func只是爲了演示，並未根據fmt消息中的格式字符串來判斷變參的個數和類型，而是直接在實現中寫死了。

爲了知足代碼的可移植性，C標準庫在stdarg.h中提供了諸多便利以供實現變長長度參數時使用。這裏也列出一個簡單的例子，看看利用標準庫是如何支持變長參數的：

 1 #include <stdarg.h>#include <stdio.h>
 2 
 3 void std_vararg_func(const char *fmt, ...) {
 4         va_list ap;
 5         va_start(ap, fmt);
 6 
 7         printf("%d\n", va_arg(ap, int));
 8         printf("%f\n", va_arg(ap, double));
 9         printf("%s\n", va_arg(ap, char*));
10 
11         va_end(ap);
12 }
13 
14 int main() {
15         std_vararg_func("%d %f %s\n", 4, 5.4, "hello world");        return 0;}

對比一下 std_vararg_func和var_args_func的實現，va_list彷佛就是char*， va_start彷佛就是 ((char*)&fmt) + sizeof(fmt)，va_arg彷佛就是獲得下一個參數的首地址。沒錯，多數平臺下stdarg.h中va_list, va_start和var_arg的實現就是相似這樣的。通常stdarg.h會包含不少宏，看起來比較複雜。

下面咱們來探討如何寫一個簡單的可變參數的C 函數.

使用可變參數應該有如下步驟:
1)首先在函數裏定義一個va_list型的變量,這裏是arg_ptr,這個變量是指向參數的指針.
2)而後用va_start宏初始化變量arg_ptr,這個宏的第二個參數是第一個可變參數的前一個參數,是一個固定的參數.
3)而後用va_arg返回可變的參數,並賦值給整數j. va_arg的第二個參數是你要返回的參數的類型,這裏是int型.
4)最後用va_end宏結束可變參數的獲取.而後你就能夠在函數裏使用第二個參數了.若是函數有多個可變參數的,依次調用va_arg獲取各個參數.

在《C程序設計語言》中，Ritchie提供了一個簡易版printf函數：

 1 #include<stdarg.h>
 2 
 3 void minprintf(char *fmt, ...)
 4 {
 5     va_list ap;
 6     char *p, *sval;
 7     int ival;
 8     double dval;
 9 
10     va_start(ap, fmt);
11     for (p = fmt; *p; p++) {
12         if(*p != '%') {
13             putchar(*p);
14             continue;
15         }
16         switch(*++p) {
17         case 'd':
18             ival = va_arg(ap, int);
19             printf("%d", ival);
20             break;
21         case 'f':
22             dval = va_arg(ap, double);
23             printf("%f", dval);
24             break;
25         case 's':
26             for (sval = va_arg(ap, char *); *sval; sval++)
27                 putchar(*sval);
28             break;
29         default:
30             putchar(*p);
31             break;
32         }
33     }
34     va_end(ap);
35 }