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中提供了諸多便利以供實現變長長度參數時使用。這里也列出一個簡單的例子，看看利用標准庫是如何支持變長參數的：

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

void std_vararg_func(const char *fmt, ...) {
        va_list ap;
        va_start(ap, fmt);

        printf("%d\n", va_arg(ap, int));
        printf("%f\n", va_arg(ap, double));
        printf("%s\n", va_arg(ap, char*));

        va_end(ap);
}

int main() {
        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函數：

#include<stdarg.h>

void minprintf(char *fmt, ...)
{
    va_list ap;
    char *p, *sval;
    int ival;
    double dval;

    va_start(ap, fmt);
    for (p = fmt; *p; p++) {
        if(*p != '%') {
            putchar(*p);
            continue;
        }
        switch(*++p) {
        case 'd':
            ival = va_arg(ap, int);
            printf("%d", ival);
            break;
        case 'f':
            dval = va_arg(ap, double);
            printf("%f", dval);
            break;
        case 's':
            for (sval = va_arg(ap, char *); *sval; sval++)
                putchar(*sval);
            break;
        default:
            putchar(*p);
            break;
        }
    }
    va_end(ap);
}