1，首先，怎么得到參數的值。對于一般的函數，我們可以通過參數對應在參數列表里的標識符來得到。但是參數可變函數那些可變的參數是沒有參數標識符的，它只有“…”，所以通過標識符來得到是不可能的，我們只有另辟途徑。
我們知道函數調用時都會分配棧空間，而函數調用機制中的棧結構如下圖所示：
| ...... |
------------------
| 參數2 |
------------------
| 參數1 |
------------------
| 返回地址 |
------------------
|調用函數運行狀態|
------------------
可見，參數是連續存儲在棧里面的，那么也就是說，我們只要得到可變參數的前一個參數的地址，就可以通過指針訪問到那些可變參數。但是怎么樣得到可變參數的前一個參數的地址呢？不知道你注意到沒有，參數可變函數在可變參數之前必有一個參數是固定的，并使用標識符，而且通常被聲明為char*類型，printf函數也不例外。這樣的話，我們就可以通過這個參數對應的標識符來得到地址，從而訪問其他參數變得可能。我們可以寫一個測試程序來試一下：
#include <stdio.h>
void va_test(char* fmt,...);//參數可變的函數聲明
void main()
{
int a=1,c=55;
char b='b';
va_test("",a,b,c);//用四個參數做測試
}
void va_test(char* fmt,...) //參數可變的函數定義，注意第一個參數為char* fmt
{
char *p=NULL;
p=(char *)&fmt;//注意不是指向fmt，而是指向&fmt，并且強制轉化為char *,以便一個一個字節訪問
for(int i = 0;i<16;i++)//16是通過計算的值（參數個數*4個字節），只是為了測試，暫且將就一下
{
printf("%.4d ",*p);//輸出p指針指向地址的值
p++;
}
}
編譯運行的結果為
0056 0000 0066 0000 | 0001 0000 0000 0000 | 0098 0000 0000 0000 | 0055 0000 0000 0000
由運行結果可見，通過這樣方式可以逐一獲得可變參數的值。
至于為什么通常被聲明為char*類型，我們慢慢看來。
2，怎樣確定參數類型和數量
通過上述的方式，我們首先解決了取得可變參數值的問題，但是對于一個參數，值很重要，其類型同樣舉足輕重，而對于一個函數來講參數個數也非常重要，否則就會產生了一系列的麻煩來。通過訪問存儲參數的棧空間，我們并不能得到關于類型的任何信息和參數個數的任何信息。我想你應該想到了——使用char *參數。Printf函數就是這樣實現的，它把后面的可變參數類型都放到了char *指向的字符數組里，并通過%來標識以便與其它的字符相區別，從而確定了參數類型也確定了參數個數。其實，用何種方式來到達這樣的效果取決于函數的實現。比如說，定義一個函數，預知它的可變參數類型都是int，那么固定參數完全可以用int類型來替換char*類型，因為只要得到參數個數就可以了。
3，言歸正傳
我想到了這里，大概的輪廓已經呈現出來了。本來想就此作罷的（我的惰性使然），但是一想到如果不具實用性便可能是一堆廢物，枉費我打了這么些字，決定還是繼續下去。
我是比較抵制用那些不明所以的宏定義的，所以在上面的闡述里一點都沒有涉及定義在<stdarg.h>的va(variable-argument)宏。事實上，當時讓我產生極大疑惑和好奇的正是這幾個宏定義。但是現在我們不得不要去和這些宏定義打打交道，畢竟我們在討生計的時候還得用上他們，這也是我曰之為“言歸正傳”的理由。
好了，我們來看一下那些宏定義。
打開<stdarg.h>文件，找一下va_*的宏定義，發現不單單只有一組，但是在各組定義前都會有宏編譯。宏編譯指示的是不同硬件平臺和編譯器下用怎樣的va宏定義。比較一下，不同之處主要在偏移量的計算上。我們還是拿個典型又熟悉的——X86的相關宏定義：
1)typedef char * va_list;
2)#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
3)#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )
4)#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
5)#define va_end(ap) ( ap = (va_list)0 )
我們逐一看來：
第一個我想不必說了，類型定義罷了。第二個是頗有些來頭的，我們也不得不搞懂它，因為后面的兩個關鍵的宏定義都用到了。不知道你夠不夠細心，有沒有發現在上面的測試程序中，第二個可變參數明明是char類型，可是在輸出結果中占了4個byte。難道所有的參數都會占4個byte的空間？那如果是double類型的參數，且不是會丟失數據！如果你不嫌麻煩的話，再去做個測試吧，在上面的測試程序中用一個double類型（長度為8byte）和一個long double類型（長度為10byte）做可變參數。發現什么？double類型占了8byte,而long double占了12byte。好像都是4的整數倍哦。不得不引出另一個概念了“對齊（alignment）”,所謂對齊，對Intel80x86 機器來說就是要求每個變量的地址都是sizeof(int)的倍數。原來我們搞錯了，char類型的參數只占了1byte，但是它后面的參數因為對齊的關系只能跳過3byte存儲，而那3byte也就浪費掉了。那為什么要對齊？因為在對齊方式下，CPU 的運行效率要快得多（舉個例子吧，要說明的是下面的例子是我從網上摘錄下來的，不記得出處了。
示例：如下圖，當一個long 型數（如圖中long1）在內存中的位置正好與內存的字邊界對齊時，CPU 存取這個數只需訪問一次內存，而當一個long 型數（如圖中的long2）在內存中的位置跨越了字邊界時，CPU 存取這個數就需要多次訪問內存，如i960cx 訪問這樣的數需讀內存三次（一個BYTE、一個SHORT、一個BYTE，由CPU 的微代碼執行，對軟件透明），所以對齊方式下CPU 的運行效率明顯快多了。
1 8 16 24 32
------- ------- ------- ---------
| long1 | long1 | long1 | long1 |
------- ------- ------- ---------
| | | | long2 |
------- ------- ------- ---------
| long2 | long2 | long2 | |
------- ------- ------- ---------
| ....)。好像扯得有點遠來，但是有助于對_INTSIZEOF(n)的理解。位操作對于我來說是玄的東東。單個位運算還應付得來，而這樣一個表達式擺在面前就暈了。怎么辦？菜鳥自有菜的辦法。(待續)
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=14721
---------------------------------------------------------------------------------------------------------------------
C語言中的可變參數函數 CSDN Blog推出文章指數概念，文章指數是對Blog文章綜合評分后推算出的，綜合評分項分別是該文章的點擊量，回復次數，被網摘收錄數量，文章長度和文章類型；滿分100，每月更新一次。
第一篇
C語言編程中有時會遇到一些參數個數可變的函數,例如printf()函數,其函數原型為：
int printf( const char* format, ...);
它除了有一個參數format固定以外,后面跟的參數的個數和類型是可變的（用三個點“…”做參數占位符）,實際調用時可以有以下的形式：
printf("%d",i);
printf("%s",s);
printf("the number is %d ,string is:%s", i, s);
一個簡單的可變參數的C函數
先看例子程序。該函數至少有一個整數參數,其后占位符…，表示后面參數的個數不定。在這個例子里，所有的輸入參數必須都是整數，函數的功能只是打印所有參數的值。函數代碼如下：
//示例代碼1：可變參數函數的使用
#include "stdio.h"
#include "stdarg.h"
void simple_va_fun(int start, ...)
{
va_list arg_ptr;
int nArgValue =start;
int nArgCout="0"; //可變參數的數目
va_start(arg_ptr,start); //以固定參數的地址為起點確定變參的內存起始地址。
do
{
++nArgCout;
printf("the %d th arg: %d",nArgCout,nArgValue); //輸出各參數的值
nArgValue = va_arg(arg_ptr,int); //得到下一個可變參數的值
} while(nArgValue != -1);
return;
}
int main(int argc, char* argv[])
{
simple_va_fun(100,-1);
simple_va_fun(100,200,-1);
return 0;
}
下面解釋一下這些代碼。從這個函數的實現可以看到,我們使用可變參數應該有以下步驟：
⑴由于在程序中將用到以下這些宏:
void va_start( va_list arg_ptr, prev_param );
type va_arg( va_list arg_ptr, type );
void va_end( va_list arg_ptr );
va在這里是variable-argument(可變參數)的意思。
這些宏定義在stdarg.h中,所以用到可變參數的程序應該包含這個頭文件。
⑵函數里首先定義一個va_list型的變量,這里是arg_ptr,這個變量是存儲參數地址的指針.因為得到參數的地址之后，再結合參數的類型，才能得到參數的值。
⑶然后用va_start宏初始化⑵中定義的變量arg_ptr,這個宏的第二個參數是可變參數列表的前一個參數,即最后一個固定參數。
⑷然后依次用va_arg宏使arg_ptr返回可變參數的地址,得到這個地址之后，結合參數的類型，就可以得到參數的值。
⑸設定結束條件，這里的條件就是判斷參數值是否為-1。注意被調的函數在調用時是不知道可變參數的正確數目的，程序員必須自己在代碼中指明結束條件。至于為什么它不會知道參數的數目，在看完這幾個宏的內部實現機制后，自然就會明白。
第二篇
C語言之可變參數問題
C語言中有一種長度不確定的參數，形如："…"，它主要用在參數個數不確定的函數中，我們最容易想到的例子是printf函數。
原型：
int printf( const char *format [, argument]... );
使用例：
printf("Enjoy yourself everyday!\n");
printf("The value is %d!\n", value);
這種可變參數可以說是C語言一個比較難理解的部分，這里會由幾個問題引發一些對它的分析。
注意：在C++中有函數重載（overload）可以用來區別不同函數參數的調用，但它還是不能表示任意數量的函數參數。
問題：printf的實現
請問，如何自己實現printf函數，如何處理其中的可變參數問題？ 答案與分析：
在標準C語言中定義了一個頭文件專門用來對付可變參數列表，它包含了一組宏，和一個va_list的typedef聲明。一個典型實現如下：
typedef char* va_list;
#define va_start(list) list = (char*)&va_alist
#define va_end(list)
#define va_arg(list, mode)\
((mode*) (list += sizeof(mode)))[-1]
自己實現printf：
#include
int printf(char* format, …)
{
va_list ap;
va_start(ap, format);
int n = vprintf(format, ap);
va_end(ap);
return n;
}
問題：運行時才確定的參數
有沒有辦法寫一個函數，這個函數參數的具體形式可以在運行時才確定？
答案與分析：
目前沒有"正規"的解決辦法，不過獨門偏方倒是有一個，因為有一個函數已經給我們做出了這方面的榜樣，那就是main()，它的原型是:
int main(int argc,char *argv[]);
函數的參數是argc和argv。
深入想一下，"只能在運行時確定參數形式"，也就是說你沒辦法從聲明中看到所接受的參數，也即是參數根本就沒有固定的形式。常用的辦法是你可以通過定義一個void *類型的參數，用它來指向實際的參數區，然后在函數中根據根據需要任意解釋它們的含義。這就是main函數中argv的含義，而argc，則用來表明實際的參數個數，這為我們使用提供了進一步的方便，當然，這個參數不是必需的。
雖然參數沒有固定形式，但我們必然要在函數中解析參數的意義，因此，理所當然會有一個要求，就是調用者和被調者之間要對參數區內容的格式，大小，有效性等所有方面達成一致，否則南轅北轍各說各話就慘了。
問題：可變長參數的傳遞
有時候，需要編寫一個函數，將它的可變長參數直接傳遞給另外的函數，請問，這個要求能否實現？
答案與分析：
目前，你尚無辦法直接做到這一點，但是我們可以迂回前進，首先，我們定義被調用函數的參數為va_list類型，同時在調用函數中將可變長參數列表轉換為va_list，這樣就可以進行變長參數的傳遞了。看如下所示：
void subfunc (char *fmt, va_list argp)
{
...
arg = va_arg (fmt, argp); /* 從argp中逐一取出所要的參數 */
...
}
void mainfunc (char *fmt, ...)
{
va_list argp;
va_start (argp, fmt); /* 將可變長參數轉換為va_list */
subfunc (fmt, argp); /* 將va_list傳遞給子函數 */
va_end (argp);
...
}
問題：可變長參數中類型為函數指針
我想使用va_arg來提取出可變長參數中類型為函數指針的參數，結果卻總是不正確，為什么？
答案與分析：
這個與va_arg的實現有關。一個簡單的、演示版的va_arg實現如下：
#define va_arg(argp, type) \
(*(type *)(((argp) += sizeof(type)) - sizeof(type)))
其中，argp的類型是char *。
如果你想用va_arg從可變參數列表中提取出函數指針類型的參數，例如
int (*)()，則va_arg(argp, int (*)())被擴展為：
(*(int (*)() *)(((argp) += sizeof (int (*)())) -sizeof (int (*)())))
顯然，（int (*)() *）是無意義的。
解決這個問題的辦法是將函數指針用typedef定義成一個獨立的數據類型，例如：
typedef int (*funcptr)()；
這時候再調用va_arg(argp, funcptr)將被擴展為：
(* (funcptr *)(((argp) += sizeof (funcptr)) - sizeof (funcptr)))
這樣就可以通過編譯檢查了。
問題：可變長參數的獲取
有這樣一個具有可變長參數的函數，其中有下列代碼用來獲取類型為float的實參：
va_arg (argp, float);
這樣做可以嗎？
答案與分析：
不可以。在可變長參數中，應用的是"加寬"原則。也就是float類型被擴展成double；char, short被擴展成int。因此，如果你要去可變長參數列表中原來為float類型的參數，需要用va_arg(argp, double)。對char和short類型的則用va_arg(argp, int)。
問題：定義可變長參數的一個限制
為什么我的編譯器不允許我定義如下的函數，也就是可變長參數，但是沒有任何的固定參數？
int f (...)
{
...
}
答案與分析：
不可以。這是ANSI C 所要求的，你至少得定義一個固定參數。
這個參數將被傳遞給va_start()，然后用va_arg()和va_end()來確定所有實際調用時可變長參數的類型和值。---------------------------------------------------------------------------------------------------------------------
如何判別可變參數函數的參數類型？
函數形式如下：
void fun(char* str,...)
{
......
}
若傳的參數個數大于1，如何判別第2個以后傳參的參數類型？？？
最好有源碼說明！
沒辦法判斷的
如樓上所說,例如printf( "%d%c%s ", ....)是通過格式串中的%d, %c, %s來確定后面參數的類型,其實你也可以參考這種方法來判斷不定參數的類型.
無法判斷。可變參數實現主要通過三個宏實現：va_start, va_arg, va_end。
六、 擴展與思考
個數可變參數在聲明時只需"..."即可；但是，我們在接受這些參數時不能"..."。va函數實現的關鍵就是如何得到參數列表中可選參數，包括參數的值和類型。以上的所有實現都是基于來自stdarg.h的va_xxx的宏定義。 <思考>能不能不借助于va_xxx，自己實現VA呢？，我想到的方法是匯編。在C中，我們當然就用C的嵌入匯編來實現，這應該是可以做得到的。至于能做到什么程度，穩定性和效率怎么樣，主要要看你對內存和指針的控制了。
參考資料
1.IEEE和OpenGroup聯合開發的Single Unix specification Ver3；BR>
2.Linux man手冊；
3.x86匯編，還有一些安全編碼方面的資料。
---------------------------------------------------------------------------------------------------------------------
[轉帖]對C/C++可變參數表的深層探索
C/C++語言有一個不同于其它語言的特性，即其支持可變參數，典型的函數如printf、scanf等可以接受數量不定的參數。如：
printf ( "I love you" );
printf ( "%d", a );
printf ( "%d,%d", a, b );
第一、二、三個printf分別接受1、2、3個參數，讓我們看看printf函數的原型：
int printf ( const char *format, ... );
從函數原型可以看出，其除了接收一個固定的參數format以外，后面的參數用"…"表示。在C/C++語言中，"…"表示可以接受不定數量的參數，理論上來講，可以是0或0以上的n個參數。
本文將對C/C++可變參數表的使用方法及C/C++支持可變參數表的深層機理進行探索。
一. 可變參數表的用法
1、相關宏
標準C/C++包含頭文件stdarg.h，該頭文件中定義了如下三個宏：
void va_start ( va_list arg_ptr, prev_param ); /* ANSI version */
type va_arg ( va_list arg_ptr, type );
void va_end ( va_list arg_ptr );
在這些宏中，va就是variable argument(可變參數)的意思；arg_ptr是指向可變參數表的指針；prev_param則指可變參數表的前一個固定參數；type為可變參數的類型。va_list也是一個宏，其定義為typedef char * va_list，實質上是一 char型指針。char型指針的特點是++、--操作對其作用的結果是增1和減1（因為sizeof(char)為1），與之不同的是int等其它類型指針的++、--操作對其作用的結果是增sizeof(type)或減sizeof(type)，而且sizeof (type)大于1。
通過va_start宏我們可以取得可變參數表的首指針，這個宏的定義為：
#define va_start ( ap, v ) ( ap = (va_list)&v + _INTSIZEOF(v) )
顯而易見，其含義為將最后那個固定參數的地址加上可變參數對其的偏移后賦值給ap，這樣ap就是可變參數表的首地址。其中的_INTSIZEOF宏定義為：
#define _INTSIZEOF(n) ((sizeof ( n ) + sizeof ( int ) - 1 ) & ~( sizeof( int ) - 1 ) )
va_arg宏的意思則指取出當前arg_ptr所指的可變參數并將ap指針指向下一可變參數，其原型為：
#define va_arg(list, mode) ((mode *)(list =(char *) ((((int)list + (__builtin_alignof(mode)<=4?3:7)) &(__builtin_alignof(mode)<=4?-4:-8))+sizeof(mode))))[-1]
對這個宏的具體含義我們將在后面深入討論。
而va_end宏被用來結束可變參數的獲取，其定義為：
#define va_end ( list )
可以看出，va_end ( list )實際上被定義為空，沒有任何真實對應的代碼，用于代碼對稱，與va_start對應；另外，它還可能發揮代碼的"自注釋"作用。所謂代碼的"自注釋"，指的是代碼能自己注釋自己。
下面我們以具體的例子來說明以上三個宏的使用方法。
2、一個簡單的例子
#include <stdarg.h>
/* 函數名：max
* 功能：返回n個整數中的最大值
* 參數：num：整數的個數 ...：num個輸入的整數
* 返回值：求得的最大整數
*/
int max ( int num, ... )
{
int m = -0x7FFFFFFF; /* 32系統中最小的整數 */
va_list ap;
va_start ( ap, num );
for ( int i= 0; i< num; i++ )
{
int t = va_arg (ap, int);
if ( t > m )
{
m = t;
}
}
va_end (ap);
return m;
}
/* 主函數調用max */
int main ( int argc, char* argv[] )
{
int n = max ( 5, 5, 6 ,3 ,8 ,5); /* 求5個整數中的最大值 */
cout << n;
return 0;
}
函數max中首先定義了可變參數表指針ap，而后通過va_start ( ap, num )取得了參數表首地址（賦給了ap），其后的for循環則用來遍歷可變參數表。這種遍歷方式與我們在數據結構教材中經常看到的遍歷方式是類似的。
函數max看起來簡潔明了，但是實際上printf的實現卻遠比這復雜。max函數之所以看起來簡單，是因為：
(1) max函數可變參數表的長度是已知的，通過num參數傳入；
(2) max函數可變參數表中參數的類型是已知的，都為int型。
而printf函數則沒有這么幸運。首先，printf函數可變參數的個數不能輕易的得到，而可變參數的類型也不是固定的，需由格式字符串進行識別（由%f、%d、%s等確定），因此則涉及到可變參數表的更復雜應用。
下面我們以實例來分析可變參數表的高級應用。
二. 高級應用
下面這個程序是我們為某嵌入式系統（該系統中CPU的字長為16位）編寫的在屏幕上顯示格式字符串的函數DrawText，它的用法類似于 int printf ( const char *format, ... )函數，但其輸出的目標為嵌入式系統的液晶顯示屏幕（LED）。
///////////////////////////////////////////////////////////////////////////////
// 函數名稱: DrawText
// 功能說明: 在顯示屏上繪制文字
// 參數說明: xPos ---橫坐標的位置 [0 .. 30]
// yPos ---縱坐標的位置 [0 .. 64]
// ... 可以同數字一起顯示，需設置標志(%d、%l、%x、%s)
///////////////////////////////////////////////////////////////////////////////
extern void DrawText ( BYTE xPos, BYTE yPos, LPBYTE lpStr, ... )
{
BYTE lpData[100]; //緩沖區
BYTE byIndex;
BYTE byLen;
DWORD dwTemp;
WORD wTemp;
int i;
va_list lpParam;
memset( lpData, 0, 100);
byLen = strlen( lpStr );
byIndex = 0;
va_start ( lpParam, lpStr );
for ( i = 0; i < byLen; i++ )
{
if( lpStr[i] != ’%’ ) //不是格式符開始
{
lpData[byIndex++] = lpStr[i];
}
else
{
switch (lpStr[i+1])
{
//整型
case ’d’:
case ’D’:
wTemp = va_arg ( lpParam, int );
byIndex += IntToStr( lpData+byIndex, (DWORD)wTemp );
i++;
break;
//長整型
case ’l’:
case ’L’:
dwTemp = va_arg ( lpParam, long );
byIndex += IntToStr ( lpData+byIndex, (DWORD)dwTemp );
i++;
break;
//16進制（長整型）
case ’x’:
case ’X’:
dwTemp = va_arg ( lpParam, long );
byIndex += HexToStr ( lpData+byIndex, (DWORD)dwTemp );
i++;
break;
default:
lpData[byIndex++] = lpStr[i];
break;
}
}
}
va_end ( lpParam );
lpData[byIndex] = ’#CONTENT#’;
DisplayString ( xPos, yPos, lpData, TRUE); //在屏幕上顯示字符串lpData
}
在這個函數中，需通過對傳入的格式字符串（首地址為lpStr）進行識別來獲知可變參數個數及各個可變參數的類型，具體實現體現在for循環中。譬如，在識別為%d后，做的是va_arg ( lpParam, int )，而獲知為%l和%x后則進行的是va_arg ( lpParam, long )。格式字符串識別完成后，可變參數也就處理完了。
在項目的最初，我們一直苦于不能找到一個好的辦法來混合輸出字符串和數字，我們采用了分別顯示數字和字符串的方法，并分別指定坐標，程序條理被破壞。而且，在混合顯示的時候，要給各類數據分別人工計算坐標，我們感覺頭疼不已。以前的函數為：
//顯示字符串
showString ( BYTE xPos, BYTE yPos, LPBYTE lpStr )
//顯示數字
showNum ( BYTE xPos, BYTE yPos, int num )
//以16進制方式顯示數字
showHexNum ( BYTE xPos, BYTE yPos, int num )
最終，我們用DrawText ( BYTE xPos, BYTE yPos, LPBYTE lpStr, ... )函數代替了原先所有的輸出函數，程序得到了簡化。就這樣，兄弟們用得爽翻了。
三. 運行機制探索
通過第2節我們學會了可變參數表的使用方法，相信喜歡拋根問底的讀者還不甘心，必然想知道如下問題：
（1）為什么按照第2節的做法就可以獲得可變參數并對其進行操作？
（2）C/C++在底層究竟是依靠什么來對這一語法進行支持的，為什么其它語言就不能提供可變參數表呢？
我們帶著這些疑問來一步步進行摸索。
3.1 調用機制反匯編
反匯編是研究語法深層特性的終極良策，先來看看2.2節例子中主函數進行max ( 5, 5, 6 ,3 ,8 ,5)調用時的反匯編：
1. 004010C8 push 5
2. 004010CA push 8
3. 004010CC push 3
4. 004010CE push 6
5. 004010D0 push 5
6. 004010D2 push 5
7. 004010D4 call @ILT+5(max) (0040100a)
從上述反匯編代碼中我們可以看出，C/C++函數調用的過程中：
第一步：將參數從右向左入棧（第1～6行）；
第二步：調用call指令進行跳轉（第7行）。
這兩步包含了深刻的含義，它說明C/C++默認的調用方式為由調用者管理參數入棧的操作，且入棧的順序為從右至左，這種調用方式稱為_cdecl調用。x86系統的入棧方向為從高地址到低地址，故第1至n個參數被放在了地址遞增的堆棧內。在被調用函數內部，讀取這些堆棧的內容就可獲得各個參數的值，讓我們反匯編到max函數的內部：
int max ( int num, ...)
{
1. 00401020 push ebp
2. 00401021 mov ebp,esp
3. 00401023 sub esp,50h
4. 00401026 push ebx
5. 00401027 push esi
6. 00401028 push edi
7. 00401029 lea edi,[ebp-50h]
8. 0040102C mov ecx,14h
9. 00401031 mov eax,0CCCCCCCCh
10. 00401036 rep stos dword ptr [edi]
va_list ap;
int m = -0x7FFFFFFF; /* 32系統中最小的整數 */
11. 00401038 mov dword ptr [ebp-8],80000001h
va_start ( ap, num );
12. 0040103F lea eax,[ebp+0Ch]
13. 00401042 mov dword ptr [ebp-4],eax
for ( int i= 0; i< num; i++ )
14. 00401045 mov dword ptr [ebp-0Ch],0
15. 0040104C jmp max+37h (00401057)
16. 0040104E mov ecx,dword ptr [ebp-0Ch]
17. 00401051 add ecx,1
18. 00401054 mov dword ptr [ebp-0Ch],ecx
19. 00401057 mov edx,dword ptr [ebp-0Ch]
20. 0040105A cmp edx,dword ptr [ebp+8]
21. 0040105D jge max+61h (00401081)
{
int t= va_arg (ap, int);
22. 0040105F mov eax,dword ptr [ebp-4]
23. 00401062 add eax,4
24. 00401065 mov dword ptr [ebp-4],eax
25. 00401068 mov ecx,dword ptr [ebp-4]
26. 0040106B mov edx,dword ptr [ecx-4]
27. 0040106E mov dword ptr [t],edx
if ( t > m )
28. 00401071 mov eax,dword ptr [t]
29. 00401074 cmp eax,dword ptr [ebp-8]
30. 00401077 jle max+5Fh (0040107f)
m = t;
31. 00401079 mov ecx,dword ptr [t]
32. 0040107C mov dword ptr [ebp-8],ecx
}
33. 0040107F jmp max+2Eh (0040104e)
va_end (ap);
34. 00401081 mov dword ptr [ebp-4],0
return m;
35. 00401088 mov eax,dword ptr [ebp-8]
}
36. 0040108B pop edi
37. 0040108C pop esi
38. 0040108D pop ebx
39. 0040108E mov esp,ebp
40. 00401090 pop ebp
41. 00401091 ret
分析上述反匯編代碼，對于一個真正的程序員而言，將是一種很大的享受；而對于初學者，也將使其受益良多。所以請一定要賴著頭皮認真研究，千萬不要被嚇倒！
行1～10進行執行函數內代碼的準備工作，保存現場。第2行對堆棧進行移動；第3行則意味著max函數為其內部局部變量準備的堆棧空間為50h字節；第11行表示把變量n的內存空間安排在了函數內部局部棧底減8的位置（占用4個字節）。
第12～13行非常關鍵，對應著va_start ( ap, num )，這兩行將第一個可變參數的地址賦值給了指針ap。另外，從第12行可以看出num的地址為ebp+0Ch；從第13行可以看出ap被分配在函數內部局部棧底減4的位置上（占用4個字節）。
第22～27行最為關鍵，對應著va_arg (ap, int)。其中，22~24行的作用為將ap指向下一可變參數（可變參數的地址間隔為4個字節，從add eax,4可以看出）；25~27行則取當前可變參數的值賦給變量t。這段反匯編很奇怪，它先移動可變參數指針，再在賦值指令里面回過頭來取先前的參數值賦給t（從mov edx,dword ptr [ecx-4]語句可以看出）。Visual C++同學玩得有意思，不知道碰見同樣的情況Visual Basic等其它同學怎么玩？
第36～41行恢復現場和堆棧地址，執行函數返回操作。
痛苦的反匯編之旅差不多結束了，看了這段反匯編我們總算弄明白了可變參數的存放位置以及它們被讀取的方式，頓覺全省輕松！
2、特殊的調用約定
除此之外，我們需要了解C/C++函數調用對參數占用空間的一些特殊約定，因為在_cdecl調用協議中，有些變量類型是按照其它變量的尺寸入棧的。
例如，字符型變量將被自動擴展為一個字的空間，因為入棧操作針對的是一個字。
參數n實際占用的空間為( ( sizeof(n) + sizeof(int) - 1 ) & ~( sizeof(int) - 1 ) )，這就是第2.1節_INTSIZEOF(v)宏的來歷！
既然如此，前面給出的va_arg ( list, mode )宏為什么玩這么大的飛機就很清楚了。這個問題就留個讀者您來分析.
http://wp1314.ycool.com/post.3001515.html