受益匪浅

最新推荐文章于 2025-08-10 23:14:27 发布

原创最新推荐文章于 2025-08-10 23:14:27 发布 · 504 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#编译器 #list #byte #汇编 #语言 #c

C/C++函数调用约定与函数名称修饰规则探讨

使用C/C++语言开发软件的程序员经常碰到这样的问题：有时候是程序编译没有问题，但是链接的时候总是报告函数不存在（经典的LNK 2001错误），有时候是程序编译和链接都没有错误，但是只要调用库中的函数就会出现堆栈异常。这些现象通常是出现在C和C++的代码混合使用的情况下或在C++程序中使用第三方的库的情况下（不是用C++语言开发的），其实这都是函数调用约定（Calling Convention）和函数名修饰（Decorated Name）规则惹的祸。函数调用方式决定了函数参数入栈的顺序，是由调用者函数还是被调用函数负责清除栈中的参数等问题，而函数名修饰规则决定了编译器使用何种名字修饰方式来区分不同的函数，如果函数之间的调用约定不匹配或者名字修饰不匹配就会产生以上的问题。本文分别对C和C++这两种编程语言的函数调用约定和函数名修饰规则进行详细的解释，比较了它们的异同之处，并举例说明了以上问题出现的原因。

函数调用约定（Calling Convention）

函数调用约定不仅决定了发生函数调用时函数参数的入栈顺序，还决定了是由调用者函数还是被调用函数负责清除栈中的参数，还原堆栈。函数调用约定有很多方式，除了常见的__cdecl，__fastcall和__stdcall之外，C++的编译器还支持thiscall方式，不少C/C++编译器还支持 naked call方式。这么多函数调用约定常常令许多程序员很迷惑，到底它们是怎么回事，都是在什么情况下使用呢？下面就分别介绍这几种函数调用约定。

1.__cdecl

编译器的命令行参数是/Gd。__cdecl方式是C/C++编译器默认的函数调用约定，所有非C++成员函数和那些没有用__stdcall或__fastcall声明的函数都默认是__cdecl方式，它使用C函数调用方式，函数参数按照从右向左的顺序入栈，函数调用者负责清除栈中的参数，由于每次函数调用都要由编译器产生清除（还原）堆栈的代码，所以使用__cdecl方式编译的程序比使用__stdcall方式编译的程序要大很多，但是 __cdecl调用方式是由函数调用者负责清除栈中的函数参数，所以这种方式支持可变参数，比如printf和windows的API wsprintf就是__cdecl调用方式。对于C函数，__cdecl方式的名字修饰约定是在函数名称前添加一个下划线；对于C++函数，除非特别使用extern "C"，C++函数使用不同的名字修饰方式。

2.__fastcall

编译器的命令行参数是/Gr。__fastcall函数调用约定在可能的情况下使用寄存器传递参数，通常是前两个 DWORD类型的参数或较小的参数使用ECX和EDX寄存器传递，其余参数按照从右向左的顺序入栈，被调用函数在返回之前负责清除栈中的参数。编译器使用两个@修饰函数名字，后跟十进制数表示的函数参数列表大小，例如：@function_name@number。需要注意的是__fastcall函数调用约定在不同的编译器上可能有不同的实现，比如16位的编译器和32位的编译器，另外，在使用内嵌汇编代码时，还要注意不能和编译器使用的寄存器有冲突。

3.__stdcall

编译器的命令行参数是/Gz，__stdcall是Pascal程序的缺省调用方式，大多数Windows的API也是__stdcall调用约定。__stdcall函数调用约定将函数参数从右向左入栈，除非使用指针或引用类型的参数，所有参数采用传值方式传递，由被调用函数负责清除栈中的参数。对于C函数，__stdcall的名称修饰方式是在函数名字前添加下划线，在函数名字后添加@和函数参数的大小，例如：_functionname@number

4.thiscall

thiscall只用在C++成员函数的调用，函数参数按照从右向左的顺序入栈，类实例的this指针通过ECX寄存器传递。需要注意的是thiscall不是C++的关键字，不能使用thiscall声明函数，它只能由编译器使用。

5.naked call

采用前面几种函数调用约定的函数，编译器会在必要的时候自动在函数开始添加保存ESI，EDI，EBX，EBP寄存器的代码，在退出函数时恢复这些寄存器的内容，使用naked call方式声明的函数不会添加这样的代码，这也就是为什么称其为naked的原因吧。naked call不是类型修饰符，故必须和_declspec共同使用。

VC的编译环境默认是使用__cdecl调用约定，也可以在编译环境的Project Setting...菜单－》C/C++ ＝》Code Generation项选择设置函数调用约定。也可以直接在函数声明前添加关键字__stdcall、__cdecl或__fastcall等单独确定函数的调用方式。在Windows系统上开发软件常用到WINAPI宏，它可以根据编译设置翻译成适当的函数调用约定，在WIN32中，它被定义为 __stdcall。

函数名字修饰（Decorated Name）方式

函数的名字修饰（Decorated Name）就是编译器在编译期间创建的一个字符串，用来指明函数的定义或原型。LINK程序或其他工具有时需要指定函数的名字修饰来定位函数的正确位置。多数情况下程序员并不需要知道函数的名字修饰，LINK程序或其他工具会自动区分他们。当然，在某些情况下需要指定函数的名字修饰，例如在C++程序中，为了让LINK程序或其他工具能够匹配到正确的函数名字，就必须为重载函数和一些特殊的函数（如构造函数和析构函数）指定名字装饰。另一种需要指定函数的名字修饰的情况是在汇编程序中调用C或C++的函数。如果函数名字，调用约定，返回值类型或函数参数有任何改变，原来的名字修饰就不再有效，必须指定新的名字修饰。C和C++程序的函数在内部使用不同的名字修饰方式，下面将分别介绍这两种方式。

1. C编译器的函数名修饰规则

对于__stdcall调用约定，编译器和链接器会在输出函数名前加上一个下划线前缀，函数名后面加上一个“@”符号和其参数的字节数，例如_functionname@number。__cdecl调用约定仅在输出函数名前加上一个下划线前缀，例如_functionname。__fastcall调用约定在输出函数名前加上一个“@”符号，后面也是一个“@”符号和其参数的字节数，例如@functionname@number。

2. C++编译器的函数名修饰规则

          C++的函数名修饰规则有些复杂，但是信息更充分，通过分析修饰名不仅能够知道函数的调用方式，返回值类型，参数个数甚至参数类型。不管 __cdecl，__fastcall还是__stdcall调用方式，函数修饰都是以一个“?”开始，后面紧跟函数的名字，再后面是参数表的开始标识和按照参数类型代号拼出的参数表。对于__stdcall方式，参数表的开始标识是“@@YG”，对于__cdecl方式则是“@@YA”，对于__fastcall方式则是“@@YI”。参数表的拼写代号如下所示：
X--void
D--char
E--unsigned char
F--short
H--int
I--unsigned int
J--long
K--unsigned long（DWORD）
M--float
N--double
_N--bool
U--struct
....
指针的方式有些特别，用PA表示指针，用PB表示const类型的指针。后面的代号表明指针类型，如果相同类型的指针连续出现，以“0”代替，一个“0” 代表一次重复。U表示结构类型，通常后跟结构体的类型名，用“@@”表示结构类型名的结束。函数的返回值不作特殊处理，它的描述方式和函数参数一样，紧跟着参数表的开始标志，也就是说，函数参数表的第一项实际上是表示函数的返回值类型。参数表后以“@Z”标识整个名字的结束，如果该函数无参数，则以“Z”标识结束。下面举两个例子，假如有以下函数声明：

int Function1(char *var1,unsigned long);

其函数修饰名为“?Function1@@YGHPADK@Z”，而对于函数声明：

void Function2();

其函数修饰名则为“?Function2@@YGXXZ” 。

对于C++的类成员函数（其调用方式是thiscall），函数的名字修饰与非成员的C++函数稍有不同，首先就是在函数名字和参数表之间插入以“@”字符引导的类名；其次是参数表的开始标识不同，公有（public）成员函数的标识是“@@QAE”,保护（protected）成员函数的标识是“@@IAE”,私有（private）成员函数的标识是“@@AAE”，如果函数声明使用了const关键字，则相应的标识应分别为“@@QBE”，“@@IBE”和“@@ABE”。如果参数类型是类实例的引用，则使用“AAV1”，对于const类型的引用，则使用“ABV1”。下面就以类CTest为例说明C++成员函数的名字修饰规则：

class CTest
{
......
private:
void Function(int);
protected:
void CopyInfo(const CTest &src);
public:
long DrawText(HDC hdc, long pos, const TCHAR* text, RGBQUAD color, BYTE bUnder, bool bSet);
long InsightClass(DWORD dwClass) const;
......
};

对于成员函数Function，其函数修饰名为“?Function@CTest@@AAEXH@Z”，字符串“@@AAE”表示这是一个私有函数。成员函数CopyInfo只有一个参数，是对类CTest的const引用参数，其函数修饰名为“?CopyInfo@CTest@@IAEXABV1@@Z”。 DrawText是一个比较复杂的函数声明，不仅有字符串参数，还有结构体参数和HDC句柄参数，需要指出的是HDC实际上是一个HDC__结构类型的指针，这个参数的表示就是“PAUHDC__@@”，其完整的函数修饰名为“?DrawText@CTest@@QAEJPAUHDC__@@JPBDUtagRG BQUAD@@E_N@Z”。InsightClass是一个共有的const函数，它的成员函数标识是“@@QBE”，完整的修饰名就是“?InsightClass@CTest@@QBEJK@Z”。

无论是C函数名修饰方式还是C++函数名修饰方式均不改变输出函数名中的字符大小写，这和PASCAL调用约定不同，PASCAL约定输出的函数名无任何修饰且全部大写。

3.查看函数的名字修饰

有两种方式可以检查你的程序中的函数的名字修饰：使用编译输出列表或使用Dumpbin工具。使用/FAc，/FAs或/FAcs命令行参数可以让编译器输出函数或变量名字列表。使用dumpbin.exe /SYMBOLS命令也可以获得obj文件或lib文件中的函数或变量名字列表。此外，还可以使用 undname.exe 将修饰名转换为未修饰形式。

函数调用约定和名字修饰规则不匹配引起的常见问题

函数调用时如果出现堆栈异常，十有八九是由于函数调用约定不匹配引起的。比如动态链接库a有以下导出函数：

long MakeFun(long lFun);

动态库生成的时候采用的函数调用约定是__stdcall，所以编译生成的a.dll中函数MakeFun的调用约定是_stdcall，也就是函数调用时参数从右向左入栈，函数返回时自己还原堆栈。现在某个程序模块b要引用a中的MakeFun，b和a一样使用 C++方式编译，只是b模块的函数调用方式是__cdecl，由于b包含了a提供的头文件中MakeFun函数声明，所以MakeFun在b模块中被其它调用MakeFun的函数认为是__cdecl调用方式，b模块中的这些函数在调用完MakeFun当然要帮着恢复堆栈啦，可是MakeFun已经在结束时自己恢复了堆栈，b模块中的函数这样多此一举就引起了栈指针错误，从而引发堆栈异常。宏观上的现象就是函数调用没有问题（因为参数传递顺序是一样的），MakeFun也完成了自己的功能，只是函数返回后引发错误。解决的方法也很简单，只要保证两个模块的在编译时设置相同的函数调用约定就行了。

在了解了函数调用约定和函数的名修饰规则之后，再来看在C++程序中使用C语言编译的库时经常出现的LNK 2001错误就很简单了。还以上面例子的两个模块为例，这一次两个模块在编译的时候都采用__stdcall调用约定，但是a.dll使用C语言的语法编译的（C语言方式），所以a.dll的载入库a.lib中MakeFun函数的名字修饰就是“_MakeFun@4”。b包含了a提供的头文件中MakeFun函数声明，但是由于b采用的是C++语言编译，所以MakeFun在b模块中被按照C++的名字修饰规则命名为“?MakeFun@@YGJJ@Z”，编译过程相安无事，链接程序时c++的链接器就到a.lib中去找“?MakeFun@@YGJJ@Z”，但是a.lib中只有“_MakeFun@4”，没有“?MakeFun@@YGJJ@Z”，于是链接器就报告：

error LNK2001: unresolved external symbol ?MakeFun@@YGJJ@Z

解决的方法和简单，就是要让b模块知道这个函数是C语言编译的，extern "C"可以做到这一点。一个采用C语言编译的库应该考虑到使用这个库的程序可能是C++程序（使用C++编译器），所以在设计头文件时应该注意这一点。通常应该这样声明头文件：

#ifdef _cplusplus
extern "C" {
#endif

long MakeFun(long lFun);

#ifdef _cplusplus
}
#endif

这样C++的编译器就知道MakeFun的修饰名是“_MakeFun@4”，就不会有链接错误了。

许多人不明白，为什么我使用的编译器都是VC的编译器还会产生“error LNK2001”错误？其实，VC的编译器会根据源文件的扩展名选择编译方式，如果文件的扩展名是“.C”，编译器会采用C的语法编译，如果扩展名是 “.cpp”，编译器会使用C++的语法编译程序，所以，最好的方法就是使用extern "C"。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
大家会注意到，像gcc之类的编译器也是采用__cdecl方式，这样对于printf（“％d ％d“，i＋＋，i＋＋）之类的输出结果的疑问就迎刃而解了。

另外引出的一个问题是C语言的变参数函数，对于这部分估计很少大学会涉及到，但这的确是C语言很常见的一个特性，比如printf等。
上面提到对于可变参数的支持，需要由函数调用者负责清除栈中的函数参数，但为什么非要这样才可以支持变参数呢？
函数调用所涉及到的参数传递是通过栈来实现的，子函数从栈中读取传递给它的参数，如果是从左向右压栈的话那么子函数的最后一个参数在栈顶，然后依次是倒数第二个参数......；如果是从右向左压栈的话那么子函数的第一个参数在栈顶，然后依次是第二个参数......，压栈的顺序问题决定了子函数读取其参数的位置。对于变参数的函数本身来讲，并不知道有几个参数，需要某些信息才能知道，对于printf来讲，就是从前面的格式化字符串fmt来分析出来，一共有几个参数。所以被调函数返回清理栈的方式，对于可变参数是无法实现的，因为被调函数不知道要弹出参数的数量。而对于函数调用着，自己传递给被调函数多少参数（通过把参数压栈）当然是一清二楚的，这样被调函数返回后的堆栈清理也就可以做到准确无误了（不会多也不会少地把参数清理干净）。（该色部分属于个人理解，如有错误，还望指点，以免误人子弟！谢谢！）

http://hi.baidu.com/wangpeng1314/blog/item/a9c239128817e6cac2fd78a6.html

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.youkuaiyun.com/TrackBack.aspx?PostId=14721

---------------------------------------------------------------------------------------------------------------------

C语言中的可变参数函数    优快云 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] = ’/0’;
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 )宏为什么玩这么大的飞机就很清楚了。这个问题就留个读者您来分析