c++函数调用约定学习（一）

布满荆棘的人生 2022-08-06 17:21 223阅读 0赞

函数调用约定  
常见的函数调用约定\[5\]：cdecl,stdcall,fastcall,thiscall,naked call  
MFC调用约定(VS6:Project Settings->C/C++ <Category:Code Generation> Calling convention:)  
  
1, \_\_cdecl（C调用约定.The C default calling convention）C/C++ 缺省调用方式  
1)压栈顺序:函数参数从右到左  
2)参数栈维护:由调用函数把参数弹出栈,传送参数的内存栈由调用函数来维护  
（正因为如此，实现可变参数vararg的函数(如printf)只能使用该调用约定）  
3)函数修饰名约定:VC将函数编译后会在函数名前面加上下划线前缀  
4)每一个调用它的函数都包含清空堆栈的代码，所以产生的可执行文件大小会比调用\_stdcall函数的大  
  
2, \_\_stdcall (Pascal方式清理C方式压栈，通常用于Win32 Api中)  
1)压栈顺序:函数参数从右到左的压栈顺序  
2)参数栈维护:被调用函数把参数弹出栈(在退出时清空堆栈)  
　3)函数修饰名约定:VC将函数编译后会在函数名前面加上下划线前缀，在函数名后加上"@"和参数的字节数  
ex. VC: int f(void \*p) (编译后)-> [\_f@4][f_4](在外部汇编语言里可以用这个名字引用这个函数)  
  
3, \_\_fastcall (快速调用约定,通过寄存器来传送参数)  
1)压栈顺序:用ECX和EDX传送前两个双字（DWORD）或更小的参数，剩下的参数仍旧自右向左压栈传送  
2)参数栈维护:被调用函数在返回前清理传送参数的内存栈  
3)函数修饰名约定:VC将函数编译后会在函数名前面加上"@"前缀，在函数名后加上"@"和参数的字节数  
  
4, thiscall (本身调用,仅用于“C++”成员函数)  
1)压栈顺序:this指针存放于CX/ECX寄存器中，参数从右到左的压栈顺序  
2)thiscall不是关键词，因此不能被程序员指定  
  
5, naked call (裸调)  
1)当采用1-4的调用约定时，如果必要的话，进入函数时编译器会产生代码来  
保存ESI，EDI，EBX，EBP寄存器,退出函数时则产生代码恢复这些寄存器的内容  
(这些代码称作 prolog and epilog code,一般，ebp,esp的保存是必须的)  
2)naked call不产生这样的代码。naked call不是类型修饰符，故必须和\_declspec共同使用  
  
关键字 \_\_stdcall、\_\_cdecl和\_\_fastcall(1-3)可以直接加在要输出的函数前。  
它们对应的命令行参数分别为/Gz、/Gd和/Gr。缺省状态为/Gd，即\_\_cdecl  
要完全模仿PASCAL调用约定首先必须使用\_\_stdcall调用约定，函数名修饰约定可通过其它方法模仿  
WINAPI宏，Windows.h支持该宏，它可以将出函数翻译成适当的调用约定，  
在WIN32中，它被定义为\_\_stdcall。使用WINAPI宏可以创建自己的APIs  
  
\----------------------------------------------------  
引用:  
很多API函数就是象这样声明的:  
int WINAPI MessageBoxA(HWND,LPCSTR,LPSTR,UINT);  
而WINAPI实际上就是\_\_stdcall.  
大多数API都采用\_\_stdcall调用规范,这是因为几乎所有的语言都支持\_\_stdcall调用.  
相比之下,\_\_cdecl只有在C语言中才能用. 但\_\_cdecl调用有一个特点,就是能够实现可变参数的函数调用,  
比如printf,这用\_\_stdcall调用是不可能的.  
\_\_fastcall这种调用规范比较少见,但是在Borland C++ Builder中比较多的采用了这种调用方式.  
如果有共享代码的需要,比如写DLL,推荐的方法是用\_\_stdcall调用,因为这样适用范围最广.  
如果是C++语言写的代码供Delphi这样的语言调用就必须声明为\_\_stdcall,  
因为Pascal不支持cdecl调用(或许Delphi的最新版本能够支持也说不定,这个不太清楚).  
在其他一些地方,比如写COM组件,几乎都用的是stdcall调用.  
在VC或Delphi或C++Builder里面都可以从项目设置中更改默认的函数调用规范,  
当然也可在函数声明时加入\_\_stdcall,\_\_cdecl,\_\_fastcall关键字来明确的指示本函数用哪种调用约定.

\_\_declspec一般都是用来声明DLL中的导出函数.这个关键字也有一些其他的用法,不过非常罕见.  
\_\_declspec主要是用于说明DLL的引出函数的,在某些情况下用\_\_declspec(dllexport)在DLL中声明引出函数,  
比用传统的DEF文件方便.在普通程序中也可用\_\_declspec(dllimport)说明函数是位于另一个DLL中的导出函数.

例子不太好举啊,其实就是在函数声明的时候多加一个关键字,比如很多API函数就是象这样声明的:  
int WINAPI MessageBoxA(HWND,LPCSTR,LPSTR,UINT);  
而WINAPI实际上就是\_\_stdcall.  
大多数API都采用\_\_stdcall调用规范,这是因为几乎所有的语言都支持\_\_stdcall调用.相比之下,\_\_cdecl只有在C语言中才能用.但是\_\_cdecl调用有一个特点,就是能够实现可变参数的函数调用,比如printf,这用\_\_stdcall调用是不可能的.  
\_\_fastcall这种调用规范比较少见,但是在Borland C++ Builder中比较多的采用了这种调用方式.  
如果有共享代码的需要,比如写DLL,推荐的方法是用\_\_stdcall调用,因为这样适用范围最广.如果是C++语言写的代码供Delphi这样的语言调用就必须声明为\_\_stdcall,因为Pascal不支持cdecl调用(或许Delphi的最新版本能够支持也说不定,这个我不太清楚).在其他一些地方,比如写COM组件,几乎都用的是stdcall调用.在VC或Delphi或C++Builder里面都可以从项目设置中更改默认的函数调用规范,当然你也可以在函数声明的时候加入\_\_stdcall,\_\_cdecl,\_\_fastcall关键字来明确的指示本函数用哪种调用规范.  
\_\_declspec一般都是用来声明DLL中的导出函数.这个关键字也有一些其他的用法,不过非常罕见.

关于DLL的函数：  
  
动态链接库中定义有两种函数：导出函数(export function)和内部函数(internal function)。  
导出函数可以被其它模块调用，内部函数在定义它们的DLL程序内部使用。  
  
输出函数的方法有以下几种：  
  
1、传统的方法  
  
在模块定义文件的EXPORT部分指定要输入的函数或者变量。语法格式如下：  
entryname\[=internalname\] \[@ordinal\[NONAME\]\] \[DATA\] \[PRIVATE\]  
  
其中：  
  
entryname是输出的函数或者数据被引用的名称；  
  
internalname同entryname;  
  
@ordinal表示在输出表中的顺序号(index)；  
  
NONAME仅仅在按顺序号输出时被使用（不使用entryname）；  
  
DATA表示输出的是数据项，使用DLL输出数据的程序必须声明该数据项为\_declspec(dllimport)。  
  
上述各项中，只有entryname项是必须的，其他可以省略。  
  
对于“C”函数来说，entryname可以等同于函数名；但是对“C++”函数（成员函数、非成员函数）  
来说，entryname是修饰名。可以从.map映像文件中得到要输出函数的修饰名，或者使用  
DUMPBIN /SYMBOLS得到，然后把它们写在.def文件的输出模块。DUMPBIN是VC提供的一个工具。  
  
如果要输出一个“C++”类，则把要输出的数据和成员的修饰名都写入.def模块定义文件。  
  
2、在命令行输出  
  
对链接程序LINK指定/EXPORT命令行参数，输出有关函数。  
  
3、使用MFC提供的修饰符号\_declspec(dllexport)  
  
在要输出的函数、类、数据的声明前加上\_declspec(dllexport)的修饰符，表示输出。\_\_declspec  
(dllexport)在C调用约定、C编译情况下可以去掉输出函数名的下划线前缀。extern "C"使得在C++中  
使用C编译方式成为可能。在“C++”下定义“C”函数，需要加extern “C”关键词。用extern "C"来  
指明该函数使用C编译方式。输出的“C”函数可以从“C”代码里调用。  
  
例如，在一个C++文件中，有如下函数：  
extern "C" \{void \_\_declspec(dllexport) \_\_cdecl Test(int var);\}  
其输出函数名为：Test  
  
MFC提供了一些宏，就有这样的作用。  
  
AFX\_CLASS\_IMPORT：\_\_declspec(dllexport)  
  
AFX\_API\_IMPORT：\_\_declspec(dllexport)  
  
AFX\_DATA\_IMPORT：\_\_declspec(dllexport)  
  
AFX\_CLASS\_EXPORT：\_\_declspec(dllexport)  
  
AFX\_API\_EXPORT：\_\_declspec(dllexport)  
  
AFX\_DATA\_EXPORT：\_\_declspec(dllexport)  
  
AFX\_EXT\_CLASS： \#ifdef \_AFXEXT  
AFX\_CLASS\_EXPORT  
\#else  
AFX\_CLASS\_IMPORT  
  
AFX\_EXT\_API：\#ifdef \_AFXEXT  
AFX\_API\_EXPORT  
\#else  
AFX\_API\_IMPORT  
  
AFX\_EXT\_DATA：\#ifdef \_AFXEXT  
AFX\_DATA\_EXPORT  
\#else  
AFX\_DATA\_IMPORT  
  
像AFX\_EXT\_CLASS这样的宏，如果用于DLL应用程序的实现中，则表示输出（因为\_AFX\_EXT被定义，通  
常是在编译器的标识参数中指定该选项/D\_AFX\_EXT）；如果用于使用DLL的应用程序中，则表示输入  
（\_AFX\_EXT没有定义）。  
  
要输出整个的类，对类使用\_declspec(\_dllexpot)；要输出类的成员函数，则对该函数使用  
\_declspec(\_dllexport)。如：  
  
class AFX\_EXT\_CLASS CTextDoc : public CDocument  
\{  
…  
\}  
  
extern "C" AFX\_EXT\_API void WINAPI InitMYDLL();  
  
这几种方法中，最好采用第三种，方便好用；其次是第一种，如果按顺序号输出，调用效率会高些；  
最次是第二种。  
  
//  
模块定义文件(.DEF)  
  
模块定义文件(.DEF)是一个或多个用于描述DLL属性的模块语句组成的文本文件，每个DEF文件至少必  
须包含以下模块定义语句：  
  
\* 第一个语句必须是LIBRARY语句，指出DLL的名字；  
\* EXPORTS语句列出被导出函数的名字；将要输出的函数修饰名罗列在EXPORTS之下，这个名字必须与  
定义函数的名字完全一致，如此就得到一个没有任何修饰的函数名了。  
\* 可以使用DESCRIPTION语句描述DLL的用途(此句可选)；

\* ";"对一行进行注释(可选)。  
  
  
DLL程序和调用其输出函数的程序的关系  
  
1、dll与进程、线程之间的关系  
  
DLL模块被映射到调用它的进程的虚拟地址空间。  
DLL使用的内存从调用进程的虚拟地址空间分配，只能被该进程的线程所访问。  
DLL的句柄可以被调用进程使用；调用进程的句柄可以被DLL使用。  
DLL使用调用进程的栈。  
  
2、关于共享数据段  
  
DLL定义的全局变量可以被调用进程访问；DLL可以访问调用进程的全局数据。使用同一DLL的每一个  
进程都有自己的DLL全局变量实例。如果多个线程并发访问同一变量，则需要使用同步机制；对一个  
DLL的变量，如果希望每个使用DLL的线程都有自己的值，则应该使用线程局部存储(TLS，Thread  
Local Strorage)。  
  
在程序里加入预编译指令，或在开发环境的项目设置里也可以达到设置数据段属性的目的.必须给  
这些变量赋初值,否则编译器会把没有赋初始值的变量放在一个叫未被初始化的数据段中。  
  
extern "C" 指示编译器用C语言方法给函数命名。  
  
在制作DLL导出函数时由于C++存在函数重载，因此  
\_\_declspec(dllexport) function(int,int) 在DLL会被decorate，例如被decorate成为 function\_int\_int，而且不同的编译器decorate的方法不同，造成了在用GetProcAddress取得function地址时的不便，使用extern "C"时，上述的decorate不会发生，因为C没有函数重载，但如此一来被extern"C"修饰的函数，就不具备重载能力，可以说extern 和 extern "C"不是以回事。  
  
\_\_declspec(dllexport) 声明一个导出函数，是说这个函数要从本DLL导出。我要给别人用。一般用于dll中  
\_\_declspec(dllimport) 声明一个导入函数，是说这个函数是从别的DLL导入。我要用。一般用于使用某个dll的exe中  
\_declspec(thread)可以降低程序员的负担，又能做到线程局部存储的要求。VC++允许一个变量或结构被声明为“具有线程局部性”。例如，下面的声明，如果放在一个DLL之中，将产生出一个全局变量，对每一个进程而言独一无二：  
DWORD gProgressCounter；  
但是如果这样声明，它就是对每一个线程独一无二：  
\_declspec(thread) DWORD gProgressCounter;  
每一个以这种方式声明对象的EXE和DLL，将在可执行文件中有一个特殊的节区(section),内含所有的线程局部变量。当EXE或DLL被载入时，操作系统会认识这个节区并适当的处理之。这个节区会被操作系统社定为“对每一个线程具有局部性”。  
当一个EXE被载入时，操作系统扫描可执行文件以及所有静态链接(implicity linked)的DLLs，以便找出所有的线程局部节区。所有节区的大小被加总在一起以求出每个线程启动时应该配置的内存数量。  
  
1. \_\_declspec(align(16)) struct SS\{ int a,b; \};  
它与\#pragma pack()是一对兄弟，前者规定了对齐的最小值，后者规定了对齐的最大值。同时出现时，前者优先级高。 \_\_declspec(align())的一个特点是，它仅仅规定了数据对齐的位置，而没有规定数据实际占用的内存长度，当指定的数据被放置在确定的位置之后，其后的数据填充仍然是按照\#pragma pack规定的方式填充的，这时候类/结构的实际大小和内存格局的规则是这样的：在\_\_declspec(align())之前，数据按照\#pragma pack规定的方式填充，如前所述。当遇到\_\_declspec(align())的时候，首先寻找距离当前偏移向后最近的对齐点（满足对齐长度为max(数据自身长度,指定值))，然后把被指定的数据类型从这个点开始填充，其后的数据类型从它的后面开始，仍然按照\#pragma pack填充，直到遇到下一个\_\_declspec(align())。当所有数据填充完毕，把结构的整体对齐数值和\_\_declspec(align())规定的值做比较，取其中较大的作为整个结构的对齐长度。 特别的，当\_\_declspec(align())指定的数值比对应类型长度小的时候，这个指定不起作用。  
2. \#pragma section("segname",read)  
/ \_\_declspec(allocate("segname")) int i = 0;  
/ int main()\{ return 1;\};  
此关键词必须跟随code\_seg,const\_seg,data\_seg,init\_seg,section关键字之后使用，以上例子使用了section关键字。使用此关键字将告知编译器，其后的变量间被分配在那个数据段。  
3. \_\_declspec(deprecated(MY\_TEXT)) void func(int) \{\}  
与pragma deprecated()相同。此声明后，如果在同一作用域中使用func(int)函数，将被提醒c4996警告。  
4. \_\_declspec( dllimport ) declarator  
& \_\_declspec( dllexport ) declarator  
无须多说，此二关键字用于导入导出外接元素。  
5. \_\_declspec(jitintrinsic)  
用于标记一个函数或元素为64位公共语言运行时。具体用法未见到。  
6. \_\_declspec( naked ) int func( formal\_parameters ) \{\}  
此关键字仅用于x86系统，多用于硬件驱动。此关键字可以使编译器在生成代码时不包含任何注释或标记。仅可以对函数的定义使用，不能用于数据声明、定义，或者函数的声明。  
7. \_\_declspec(restrict) float \* init(int m, int n) \{\};  
& \_\_declspec(noalias) void multiply(float \* a, float \* b, float \* c) \{\}；// 优化必用！  
\_\_declspec(restrict)仅适用于返回指针的函数声明，如 \_\_declspec(restrict) void \*malloc(size\_t size);restrict declspec 适用于返回非别名指针的函数。此关键字用于 malloc 的 C 运行时库实现，因为它决不会返回已经在当前程序中使用的指针值（除非您执行某个非法操作，如在内存已被释放之后使用它）。restrict declspec 为编译器提供执行编译器优化的更多信息。对于编译器来说，最大的困难之一是确定哪些指针会与其他指针混淆，而使用这些信息对编译器很有帮助。有必要指出，这是对编译器的一个承诺，编译器并不对其进行验证。如果您的程序不恰当地使用 restrict declspec，则该程序的行为会不正确。 \_\_declspec(noalias)也是仅适用于函数，它指出该函数是半纯粹的函数。半纯粹的函数是指仅引用或修改局部变量、参数和第一层间接参数。此 declspec 是对编译器的一个承诺，如果该函数引用全局变量或第二层间接指针参数，则编译器会生成将中断应用程序的代码。  
8. class X \{  
/ \_\_declspec(noinline) int mbrfunc() \{ return 0; /\* will not inline\*/ \};  
在类中声明一个函数不需要内联。  
9. \_\_declspec(noreturn) extern void fatal () \{\}  
不需要返回值。  
10. void \_\_declspec(nothrow) \_\_stdcall f2();  
不存在异常抛出。  
11. struct \_\_declspec(novtable) X \{ virtual void mf(); \};  
/ struct Y : public X \{void mf() \{printf\_s("In Y/n");\}\};  
此关键字标记的类或结构不能直接实例化，否则将引发AV错误(access violation)。此关键字的声明将阻止编译器对构造和析构函数的vfptr的初始化。可优化编译后代码大小。  
12. struct S \{ int i;  
/ void putprop(int j) \{ i = j; \}  
/ int getprop() \{ return i; \}  
/ \_\_declspec(property(get = getprop, put = putprop)) int the\_prop;\};  
此关键字与C\#中get & set属性相同，可定义实现针对一个字段的可读或可写。以上例子，可以使用(如果实例化S为ss)如：ss.the\_prop = 156;(此时，ss.i == 156)接着如果：cout<< s.the\_prop;(此时将调用getprop，使返回156)。  
13. \_\_declspec(selectany)（转）  
在MFC，ATL的源代码中充斥着\_\_declspec(selectany)的声明。selectany可以让我们在.h文件中初始化一个全局变量而不是只能放在.cpp中。比如有一个类，其中有一个静态变量，那么我们可以在.h中通过类似\_\_declspec(selectany) type class::variable = value; 这样的代码来初始化这个全局变量。既是该.h被多次include，链接器也会为我们剔除多重定义的错误。对于template的编程会有很多便利。  
14. \_\_declspec(thread) int in\_One\_Thread;  
声明in\_One\_Thread为线程局部变量并具有线程存储时限，以便链接器安排在创建线程时自动分配的存储。  
15. struct \_\_declspec(uuid("00000000-0000-0000-c000-000000000046")) IUnknown;  
将具有唯一表示符号的已注册内容声明为一个变量，可使用\_\_uuidof()调用。

\---------------

\_\_cdecl,\_\_stdcal和\_\_fastcalll 这三个修饰符是c和c++调用约定

调用约定(Calling convention)决定以下内容：函数参数的压栈顺序，由调用者还是被调用者把参数弹出栈，以及产生函数修饰名的方法。MFC支持以下调用约定：

\_\_cdecl,\_\_stdcal和\_\_fastcalll都是函数调用规范,规定了参数出入栈的顺序和方法,如果只用VC编程的话可以不用关心,但是要在C++和Pascal等其他语言通信的时候就要注意了,只有用相同的方法才能够调用成功.另外,像printf这样接受可变个数参数的函数只有用cdecl才能够实现.

\_cdecl

按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于“C”函数或者变量，修饰名是在函数名前加下划线。对于“C++”函数，有所不同。

如函数void test(void)的修饰名是\_test；对于不属于一个类的“C++”全局函数，修饰名是[?test@@ZAXXZ][test_ZAXXZ]。

这是MFC缺省调用约定。由于是调用者负责把参数弹出栈，所以可以给函数定义个数不定的参数，如printf函数。

\_stdcall

按从右至左的顺序压参数入栈，由被调用者把参数弹出栈。对于“C”函数或者变量，修饰名以下划线为前缀，然后是函数名，然后是符号“@”及参数的字节数，如函数int func(int a, double b)的修饰名是[\_func@12][func_12]。对于“C++”函数，则有所不同。

所有的Win32 API函数都遵循该约定。

\_fastcall

是把函数参数列表的前三个参数放入寄存器eax,edx,ecx,其他参数压栈。 fastcall是BCB为了更好的兼容Delphi写的VCL而用的，delphi中的默认call是fastcall，是把函数参数列表的前三个参数放入寄存器。

举个例子,其实就是在函数声明的时候多加一个关键字,比如很多API函数就是象这样声明的:  
int WINAPI MessageBoxA(HWND,LPCSTR,LPSTR,UINT);  
而WINAPI实际上就是\_\_stdcall.  
大多数API都采用\_\_stdcall调用规范,这是因为几乎所有的语言都支持\_\_stdcall调用.相比之下,\_\_cdecl只有在C语言中才能用.但是\_\_cdecl调用有一个特点,就是能够实现可变参数的函数调用,比如printf,这用\_\_stdcall调用是不可能的.  
\_\_fastcall这种调用规范比较少见,但是在Borland C++ Builder中比较多的采用了这种调用方式.  
如果有共享代码的需要,比如写DLL,推荐的方法是用\_\_stdcall调用,因为这样适用范围最广.如果是C++语言写的代码供Delphi这样的语言调用就必须声明为\_\_stdcall,因为Pascal不支持cdecl调用(或许Delphi的最新版本能够支持也说不定,这个我不太清楚).在其他一些地方,比如写COM组件,几乎都用的是stdcall调用.在VC或Delphi或C++Builder里面都可以从项目设置中更改默认的函数调用规范,当然你也可以在函数声明的时候加入\_\_stdcall,\_\_cdecl,\_\_fastcall关键字来明确的指示本函数用哪种调用规范.

\_\_declspec主要是用于说明DLL的引出函数的,在某些情况下用\_\_declspec(dllexport)在DLL中生命引出函数,比用传统的DEF文件方便一些.在普通

程序中也可以用\_\_declspec(dllimport)说明函数是位于另一个DLL中的导出函数.

cdecl 由调用者清除堆栈  
stdcall 由被调的函数清除堆栈  
fastcall 是把函数参数列表的前三个参数放入寄存器eax,edx,ecx,其他参数压栈。

1.今天写线程函数时，发现msdn中对ThreadProc的定义有要求：DWORD WINAPI ThreadProc(LPVOID lpParameter);

不解为什么要用WINAPI宏定义，查了后发现下面的定义。于是乎需要区别\_\_stdcall和\_\_cdecl两者的区别； \#define CALLBACK \_\_stdcall  
\#define WINAPI \_\_stdcall  
\#define WINAPIV \_\_cdecl  
\#define APIENTRY WINAPI  
\#define APIPRIVATE \_\_stdcall  
\#define PASCAL \_\_stdcall  
\#define cdecl \_cdecl  
\#ifndef CDECL  
\#define CDECL \_cdecl  
\#endif

几乎我们写的每一个WINDOWS API函数都是\_\_stdcall类型的，首先，需要了解两者之间的区别： WINDOWS的函数调用时需要用到栈（STACK，一种先入后出的存储结构）。当函数调用完成后，栈需要清楚，这里就是问题的关键，如何清除？？ 如果我们的函数使用了\_cdecl，那么栈的清除工作是由调用者，用COM的术语来讲就是客户来完成的。这样带来了一个棘手的问题，不同的编译器产生栈的方式不尽相同，那么调用者能否正常的完成清除工作呢？答案是不能。 如果使用\_\_stdcall，上面的问题就解决了，函数自己解决清除工作。所以，在跨（开发）平台的调用中，我们都使用\_\_stdcall（虽然有时是以WINAPI的样子出现）。那么为什么还需要\_cdecl呢？当我们遇到这样的函数如fprintf()它的参数是可变的，不定长的，被调用者事先无法知道参数的长度，事后的清除工作也无法正常的进行，因此，这种情况我们只能使用\_cdecl。到这里我们有一个结论，如果你的程序中没有涉及可变参数，最好使用\_\_stdcall关键字。

2.\_\_cdecl,\_\_stdcall是声明的函数调用协议.主要是传参和弹栈方面的不同.一般c++用的是\_\_cdecl,windows里大都用的是\_\_stdcall(API)

\_\_cdecl是C/C++和MFC程序默认使用的调用约定，也可以在函数声明时加上\_\_cdecl关键字来手工指定。采用\_\_cdecl约定时，函数参数按照从右到左的顺序入栈，并且由调用函数者把参数弹出栈以清理堆栈。因此，实现可变参数的函数只能使用该调用约定。由于每一个使用\_\_cdecl约定的函数都要包含清理堆栈的代码，所以产生的可执行文件大小会比较大。\_\_cdecl可以写成\_cdecl。  
\_\_stdcall调用约定用于调用Win32 API函数。采用\_\_stdcall约定时，函数参数按照从右到左的顺序入栈，被调用的函数在返回前清理传送参数的栈，函数参数个数固定。由于函数体本身知道传进来的参数个数，因此被调用的函数可以在返回前用一条ret n指令直接清理传递参数的堆栈。\_\_stdcall可以写成\_stdcall。  
\_\_fastcall约定用于对性能要求非常高的场合。\_\_fastcall约定将函数的从左边开始的两个大小不大于4个字节（DWORD）的参数分别放在ECX和EDX寄存器，其余的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的堆栈。\_\_fastcall可以写成\_fastcall

3.\_\_stdcall:

\_stdcall 调用约定相当于16位动态库中经常使用的PASCAL调用约定。

在32位的VC++5.0中PASCAL调用约定不再被支持（实际上它已被定义为\_\_stdcall。除了\_\_pascal外，\_\_fortran和\_\_syscall也不被支持），取而代之的是\_\_stdcall调用约定。两者实质上是一致的，即函数的参数自右向左通过栈传递，被调用的函数在返回前清理传送参数的内存栈，但不同的是函数名的修饰部分（关于函数名的修饰部分在后面将详细说明）。

\_stdcall是Pascal程序的缺省调用方式，通常用于Win32 Api中，函数采用从右到左的压栈方式，自己在退出时清空堆栈。VC将函数编译后会在函数名前面加上下划线前缀，在函数名后加上"@"和参数的字节数。

\_cdecl:

\_cdecl c调用约定, 按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于传送参数的内存栈是由调用者来维护的（正因为如此，实现可变参数的函数只能使用该调用约定）。另外，在函数名修饰约定方面也有所不同。

\_cdecl是C和C＋＋程序的缺省调用方式。每一个调用它的函数都包含清空堆栈的代码，所以产生的可执行文件大小会比调用\_stdcall函数的大。函数采用从右到左的压栈方式。VC将函数编译后会在函数名前面加上下划线前缀。是MFC缺省调用约定。

\_\_fastcall:

\_\_fastcall调用约定是"人"如其名，它的主要特点就是快，因为它是通过寄存器来传送参数的（实际上，它用ECX和EDX传送前两个双字（DWORD）或更小的参数，剩下的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的内存栈），在函数名修饰约定方面，它和前两者均不同。

\_fastcall方式的函数采用寄存器传递参数，VC将函数编译后会在函数名前面加上"@"前缀，在函数名后加上"@"和参数的字节数。

thiscall:

thiscall仅仅应用于"C++"成员函数。this指针存放于CX寄存器，参数从右到左压。thiscall不是关键词，因此不能被程序员指定。

naked call:

采用1-4的调用约定时，如果必要的话，进入函数时编译器会产生代码来保存ESI，EDI，EBX，EBP寄存器，退出函数时则产生代码恢复这些寄存器的内容。

naked call不产生这样的代码。naked call不是类型修饰符，故必须和\_declspec共同使用。

另附:

名字修饰约定

1、修饰名(Decoration name)  
“C”或者“C++”函数在内部（编译和链接）通过修饰名识别。修饰名是编译器在编译函数定义或者原型时生成的字符串。有些情况下使用函数的修饰名是必要的，如在模块定义文件里头指定输出“C++”重载函数、构造函数、析构函数，又如在汇编代码里调用“C””或“C++”函数等。

修饰名由函数名、类名、调用约定、返回类型、参数等共同决定。

2、名字修饰约定随调用约定和编译种类(C或C++)的不同而变化。函数名修饰约定随编译种类和调用约定的不同而不同，下面分别说明。

a、C编译时函数名修饰约定规则：

\_\_stdcall调用约定在输出函数名前加上一个下划线前缀，后面加上一个“@”符号和其参数的字节数，格式为[\_functionname@number][functionname_number]。

\_\_cdecl调用约定仅在输出函数名前加上一个下划线前缀，格式为\_functionname。

\_\_fastcall调用约定在输出函数名前加上一个“@”符号，后面也是一个“@”符号和其参数的字节数，格式为@functionname@number。

它们均不改变输出函数名中的字符大小写，这和PASCAL调用约定不同，PASCAL约定输出的函数名无任何修饰且全部大写。

b、C++编译时函数名修饰约定规则：

\_\_stdcall调用约定：  
1、以“?”标识函数名的开始，后跟函数名；  
2、函数名后面以[“@@YG][YG]”标识参数表的开始，后跟参数表；  
3、参数表以代号表示：  
X--void ，  
D--char，  
E--unsigned char，  
F--short，  
H--int，  
I--unsigned int，  
J--long，  
K--unsigned long，  
M--float，  
N--double，  
\_N--bool，  
....  
PA--表示指针，后面的代号表明指针类型，如果相同类型的指针连续出现，以“0”代替，一个“0”代表一次重复；  
4、参数表的第一项为该函数的返回值类型，其后依次为参数的数据类型,指针标识在其所指数据类型前；  
5、参数表后以[“@Z][Z]”标识整个名字的结束，如果该函数无参数，则以“Z”标识结束。

其格式为[“?functionname@@YG\*\*\*\*\*@Z][functionname_YG_Z]”或[“?functionname@@YG\*XZ][functionname_YG_XZ]”，例如  
int Test1（char \*var1,unsigned long）[\-----“?Test1@@YGHPADK@Z][-----_Test1_YGHPADK_Z]”  
void Test2（） [\-----“?Test2@@YGXXZ][-----_Test2_YGXXZ]”

\_\_cdecl调用约定：  
规则同上面的\_stdcall调用约定，只是参数表的开始标识由上面的[“@@YG][YG]”变为[“@@YA][YA]”。

\_\_fastcall调用约定：  
规则同上面的\_stdcall调用约定，只是参数表的开始标识由上面的[“@@YG][YG]”变为[“@@YI][YI]”。  
VC++对函数的省缺声明是“\_\_cedcl“,将只能被C/C++调用.

CB在输出函数声明时使用4种修饰符号  
//\_\_cdecl  
cb的默认值，它会在输出函数名前加\_，并保留此函数名不变，参数按照从右到左的顺序依次传递给栈，也可以写成\_cdecl和cdecl形式。  
//\_\_fastcall  
她修饰的函数的参数将尽肯呢感地使用寄存器来处理，其函数名前加@，参数按照从左到右的顺序压栈；  
//\_\_pascal  
它说明的函数名使用Pascal格式的命名约定。这时函数名全部大写。参数按照从左到右的顺序压栈；  
//\_\_stdcall  
使用标准约定的函数名。函数名不会改变。使用\_\_stdcall修饰时。参数按照由右到左的顺序压栈，也可以是\_stdcall；

VC++对函数的省缺声明是"\_\_cedcl",将只能被C/C++调用.

注意：

1、\_beginthread需要\_\_cdecl的线程函数地址，\_beginthreadex和CreateThread需要\_\_stdcall的线程函数地址。

2、一般WIN32的函数都是\_\_stdcall。而且在Windef.h中有如下的定义：

\#define CALLBACK \_\_stdcall

\#define WINAPI　 \_\_stdcall

3、extern "C" \_declspec(dllexport) int \_\_cdecl Add(int a, int b);

typedef int (\_\_cdecl\*FunPointer)(int a, int b);

修饰符的书写顺序如上。

4、extern "C"的作用：如果Add(int a, int b)是在c语言编译器编译，而在c++文件使用，则需要在c++文件中声明：extern "C" Add(int a, int b)，因为c编译器和c++编译器对函数名的解释不一样（c++编译器解释函数名的时候要考虑函数参数，这样是了方便函数重载，而在c语言中不存在函数重载的问题），使用extern "C"，实质就是告诉c++编译器，该函数是c库里面的函数。如果不使用extern "C"则会出现链接错误。

一般象如下使用：

\#ifdef \_cplusplus

\#define EXTERN\_C extern "C"

\#else

\#define EXTERN\_C extern

\#endif

\#ifdef \_cplusplus

extern "C"\{

\#endif

EXTERN\_C int func(int a, int b);

\#ifdef \_cplusplus

\#endif

5、DLLMain负责初始化(Initialization)和结束(Termination)工作，每当一个新的进程或者该进程的新的线程访问DLL时，或者访问DLL的每一个进程或者线程不再使用DLL或者结束时，都会调用DLLMain。但是，使用TerminateProcess或TerminateThread结束进程或者线程，不会调用DLLMain。

6、一个DLL在内存中只有一个实例

7、几乎我们写的每一个WINDOWS API函数都是\_\_stdcall类型的，首先，需要了解两者之间的区别： WINDOWS的函数调用时需要用到栈（STACK，一种先入后出的存储结构）。当函数调用完成后，栈需要清除，这里就是问题的关键，如何清除？？如果我们的函数使用了\_cdecl，那么栈的清除工作是由调用者，用COM的术语来讲就是客户来完成的。这样带来了一个棘手的问题，不同的编译器产生栈的方式不尽相同，那么调用者能否正常的完成清除工作呢？答案是不能。如果使用\_\_stdcall，上面的问题就解决了，函数自己解决清除工作。所以，在跨（开发）平台的调用中，我们都使用\_\_stdcall（虽然有时是以WINAPI的样子出现）。那么为什么还需要\_cdecl呢？当我们遇到这样的函数如fprintf()它的参数是可变的，不定长的，被调用者事先无法知道参数的长度，事后的清除工作也无法正常的进行，因此，这种情况我们只能使用\_cdecl。到这里我们有一个结论，如果你的程序中没有涉及可变参数，最好使用\_\_stdcall关键字。  
  
另：  
\_cdecl  
按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于“C”函数或者变量，修饰名是在函数名前加下划线。对于“C++”函数，有所不同。  
如函数void test(void)的修饰名是\_test；对于不属于一个类的“C++”全局函数，修饰名是[?test@@ZAXXZ][test_ZAXXZ]。  
这是MFC缺省调用约定。由于是调用者负责把参数弹出栈，所以可以给函数定义个数不定的参数，如printf函数。

stdcall 和pascal一样,都是pascal的调用习惯  
按从右至左的顺序压参数入栈，由被调用者把参数弹出栈。对于“C”函数或者变量，修饰名以下划线为前缀，然后是函数名，然后是符号“@”及参数的字节数，如函数int func(int a, double b)的修饰名是[\_func@12][func_12]。对于“C++”函数，则有所不同。

[f_4]: mailto:_f@4
[test_ZAXXZ]: mailto:?test@@ZAXXZ
[func_12]: mailto:_func@12
[functionname_number]: mailto:_functionname@number
[YG]: mailto:%E2%80%9C@@YG
[Z]: mailto:%E2%80%9C@Z
[functionname_YG_Z]: mailto:%E2%80%9C?functionname@@YG*****@Z
[functionname_YG_XZ]: mailto:%E2%80%9C?functionname@@YG*XZ
[-----_Test1_YGHPADK_Z]: mailto:-----%E2%80%9C?Test1@@YGHPADK@Z
[-----_Test2_YGXXZ]: mailto:-----%E2%80%9C?Test2@@YGXXZ
[YA]: mailto:%E2%80%9C@@YA
[YI]: mailto:%E2%80%9C@@YI