int __stdcall Sub(int numa, int numb)
{
        return (numa - numb);
}

             然后创建一个.def的文件，在里面加上

;DllTestDef.lib : 导出DLL函数
;作者：----
LIBRARY DllTestDef
EXPORTS
Add @ 1
Sub @ 2

           最后创建一个测试程序：.cpp文件如下：
#include <iostream>
#include <windows.h>

using namespace std;

typedef int (__stdcall *FUN)(int, int);
HINSTANCE hInstance;
FUN   fun;

int main()
{
       hInstance = LoadLibrary("DLLTestDef.dll");
       if(!hInstance)
           cout << "Not Find this Dll" << endl;
       fun = (FUN)GetProcAddress(hInstance, MAKEINTRESOURCE(1));
       if (!fun)
       {
              cout << "not find this fun" << endl;
       }
       cout << fun(1, 2) << endl;
       FreeLibrary(hInstance);
       return 0;
}

typedef int (*lpAdd)(int a, int b);

lpAdd lpadd;

int main()
{
          hinstance = LoadLibrary("E:\\vc\\DLL\\TestDll\\Debug\\TestDll.dll");
          lpadd = (lpAdd)GetProcAddress(hinstance, "add");
          cout << "2 + 3 = " << lpadd(2, 3) << endl;
          FreeLibrary(hinstance);
          return 0;
}
而应用程序对本DLL的调用和对第2节静态链接库的调用却有较大差异，下面我们来逐一分析。

　　首先，语句typedef int ( * lpAddFun)(int,int)定义了一个与add函数接受参数类型和返回值均相同的函数指针类型。随后，在main函数中定义了lpAddFun的实例addFun；

  　　其次，在函数main中定义了一个DLL HINSTANCE句柄实例hDll，通过Win32 Api函数LoadLibrary动态加载了DLL模块并将DLL模块句柄赋给了hDll；

 　　再次，在函数main中通过Win32 Api函数GetProcAddress得到了所加载DLL模块中函数add的地址并赋给了addFun。经由函数指针addFun进行了对DLL中add函数的调用；

   　　最后，应用工程使用完DLL后，在函数main中通过Win32 Api函数FreeLibrary释放了已经加载的DLL模块。

  　　通过这个简单的例子，我们获知DLL定义和调用的一般概念：

    　　(1)DLL中需以某种特定的方式声明导出函数（或变量、类）；

   　　(2)应用工程需以某种特定的方式调用DLL的导出函数（或变量、类）。


2）静态连接：
代码如下：
#include <iostream>
using namespace std;

#pragma comment(lib,"Testlib.lib")

//.lib文件中仅仅是关于其对应DLL文件中函数的重定位信息
extern "C" __declspec(dllimport) add(int x,int y);

int main()
{
         int result = add(2,3); 
         cout <<　result <＜　endl;
         return 0;
}

调用时只要用result = function(1,2)这样的方式就可以使用这个函数。但是，当高级语言被编译成计算机可以识别的机器码时，有一个问题就凸现出来：在CPU中，计算机没有办法知道一个函数调用需要多少个、什么样的参数，也没有硬件可以保存这些参数。也就是说，计算机不知道怎么给这个函数传递参数，传递参数的工作必须由函数调用者和函数本身来协调。为此，计算机提供了一种被称为栈的数据结构来支持参数传递。

栈是一种先进后出的数据结构，栈有一个存储区、一个栈顶指针。栈顶指针指向堆栈中第一个可用的数据项（被称为栈顶）。用户可以在栈顶上方向栈中加入数据，这个操作被称为压栈(Push)，压栈以后，栈顶自动变成新加入数据项的位置，栈顶指针也随之修改。用户也可以从堆栈中取走栈顶，称为弹出栈(pop)，弹出栈后，栈顶下的一个元素变成栈顶，栈顶指针随之修改。

函数调用时，调用者依次把参数压栈，然后调用函数，函数被调用以后，在堆栈中取得数据，并进行计算。函数计算结束以后，或者调用者、或者函数本身修改堆栈，使堆栈恢复原装。

在参数传递中，有两个很重要的问题必须得到明确说明：

• 当参数个数多于一个时，按照什么顺序把参数压入堆栈
• 函数调用后，由谁来把堆栈恢复原装

在高级语言中，通过函数调用约定来说明这两个问题。常见的调用约定有：

• stdcall
• cdecl
• fastcall
• thiscall
• naked call

stdcall调用约定

stdcall很多时候被称为pascal调用约定，因为pascal是早期很常见的一种教学用计算机程序设计语言，其语法严谨，使用的函数调用约定就是stdcall。在Microsoft C++系列的C/C++编译器中，常常用PASCAL宏来声明这个调用约定，类似的宏还有WINAPI和CALLBACK。

stdcall调用约定声明的语法为(以前文的那个函数为例）：

int __stdcall function(int a,int b)

stdcall的调用约定意味着：1）参数从右向左压入堆栈，2）函数自身修改堆栈 3)函数名自动加前导的下划线，后面紧跟一个@符号，其后紧跟着参数的尺寸

以上述这个函数为例，参数b首先被压栈，然后是参数a，函数调用function(1,2)调用处翻译成汇编语言将变成：

push 2      第二个参数入栈
push 1      第一个参数入栈
call function  调用参数，注意此时自动把cs:eip入栈

而对于函数自身，则可以翻译为：

push ebp     保存ebp寄存器，该寄存器将用来保存堆栈的栈顶指针，可以在函数退出时恢复
mov ebp,esp  保存堆栈指针
mov  eax,[ebp + 8H]  堆栈中ebp指向位置之前依次保存有ebp,cs:eip,a,b,ebp +8指向a
add eax,[ebp + 0CH]  堆栈中ebp + 12处保存了b
mov  esp,ebp         恢复esp
pop ebp
ret 8

而在编译时，这个函数的名字被翻译成_function@8

注意不同编译器会插入自己的汇编代码以提供编译的通用性，但是大体代码如此。其中在函数开始处保留esp到ebp中，在函数结束恢复是编译器常用的方法。

从函数调用看，2和1依次被push进堆栈，而在函数中又通过相对于ebp(即刚进函数时的堆栈指针）的偏移量存取参数。函数结束后，ret 8表示清理8个字节的堆栈，函数自己恢复了堆栈。

cdecl调用约定

cdecl调用约定又称为C调用约定，是C语言缺省的调用约定，它的定义语法是：

int function (int a ,int b)  //不加修饰就是C调用约定
int __cdecl function(int a,int b)//明确指出C调用约定

在写本文时，出乎我的意料，发现cdecl调用约定的参数压栈顺序是和stdcall是一样的，参数首先由有向左压入堆栈。所不同的是，函数本身不清理堆栈，调用者负责清理堆栈。由于这种变化，C调用约定允许函数的参数的个数是不固定的，这也是C语言的一大特色。对于前面的function函数，使用cdecl后的汇编码变成：

调用处
push 1
push 2
call function
add esp,8   注意：这里调用者在恢复堆栈
被调用函数_function处
push ebp     保存ebp寄存器，该寄存器将用来保存堆栈的栈顶指针，可以在函数退出时恢复
mov ebp,esp  保存堆栈指针
mov  eax,[ebp + 8H]  堆栈中ebp指向位置之前依次保存有ebp,cs:eip,a,b,ebp +8指向a
add eax,[ebp + 0CH]  堆栈中ebp + 12处保存了b
mov  esp,ebp         恢复esp
pop ebp
ret         注意，这里没有修改堆栈

MSDN中说，该修饰自动在函数名前加前导的下划线，因此函数名在符号表中被记录为_function，但是我在编译时似乎没有看到这种变化。

由于参数按照从右向左顺序压栈，因此最开始的参数在最接近栈顶的位置，因此当采用不定个数参数时，第一个参数在栈中的位置肯定能知道，只要不定的参数个数能够根据第一个后者后续的明确的参数确定下来，就可以使用不定参数，例如对于CRT中的sprintf函数，定义为：

int sprintf(char* buffer,const char* format,...)

由于所有的不定参数都可以通过format确定，因此使用不定个数的参数是没有问题的。

fastcall

fastcall调用约定和stdcall类似，它意味着：

• 函数的第一个和第二个DWORD参数（或者尺寸更小的）通过ecx和edx传递，其他参数通过从右向左的顺序压栈
• 被调用函数清理堆栈
• 函数名修改规则同stdcall

其声明语法为：int fastcall function(int a,int b)

thiscall

thiscall是唯一一个不能明确指明的函数修饰，因为thiscall不是关键字。它是C++类成员函数缺省的调用约定。由于成员函数调用还有一个this指针，因此必须特殊处理，thiscall意味着：

• 参数从右向左入栈
• 如果参数个数确定，this指针通过ecx传递给被调用者；如果参数个数不确定，this指针在所有参数压栈后被压入堆栈。
• 对参数个数不定的，调用者清理堆栈，否则函数自己清理堆栈

为了说明这个调用约定，定义如下类和使用代码：

class A
{
public:
   int function1(int a,int b);
   int function2(int a,...);
};
int A::function1 (int a,int b)
{
   return a+b;
}
#include 
int A::function2(int a,...)
{
   va_list ap;
   va_start(ap,a);
   int i;
   int result = 0;
   for(i = 0 ; i < a ; i ++)
   {
      result += va_arg(ap,int);
   }
   return result;
}
void callee()
{
   A a;
   a.function1 (1,2);
   a.function2(3,1,2,3);
}

callee函数被翻译成汇编后就变成：

//函数function1调用
0401C1D   push        2
00401C1F   push        1
00401C21   lea         ecx,[ebp-8]
00401C24   call  function1           注意，这里this没有被入栈
//函数function2调用
00401C29   push        3
00401C2B   push        2
00401C2D   push        1
00401C2F   push        3
00401C31   lea         eax,[ebp-8]   这里引入this指针
00401C34   push        eax
00401C35   call   function2
00401C3A   add         esp,14h

可见，对于参数个数固定情况下，它类似于stdcall，不定时则类似cdecl

naked call

这是一个很少见的调用约定，一般程序设计者建议不要使用。编译器不会给这种函数增加初始化和清理代码，更特殊的是，你不能用return返回返回值，只能用插入汇编返回结果。这一般用于实模式驱动程序设计，假设定义一个求和的加法程序，可以定义为：

__declspec(naked) int  add(int a,int b)
{
__asm mov eax,a
__asm add eax,b
__asm ret
}

注意，这个函数没有显式的return返回值，返回通过修改eax寄存器实现，而且连退出函数的ret指令都必须显式插入。上面代码被翻译成汇编以后变成：

mov eax,[ebp+8]
add eax,[ebp+12]
ret 8

注意这个修饰是和__stdcall及cdecl结合使用的，前面是它和cdecl结合使用的代码，对于和stdcall结合的代码，则变成：

__declspec(naked) int __stdcall function(int a,int b)
{
__asm mov eax,a
__asm add eax,b
__asm ret 8        //注意后面的8
}

至于这种函数被调用，则和普通的cdecl及stdcall调用函数一致。

函数调用约定导致的常见问题

如果定义的约定和使用的约定不一致，则将导致堆栈被破坏，导致严重问题，下面是两种常见的问题：

1. 函数原型声明和函数体定义不一致
2. DLL导入函数时声明了不同的函数约定

以后者为例，假设我们在dll种声明了一种函数为：

__declspec(dllexport) int func(int a,int b);//注意，这里没有stdcall，使用的是cdecl

使用时代码为：

      typedef int (*WINAPI DLLFUNC)func(int a,int b);
hLib = LoadLibrary(...);
DLLFUNC func = (DLLFUNC)GetProcAddress(...)//这里修改了调用约定
result = func(1,2);//导致错误

由于调用者没有理解WINAPI的含义错误的增加了这个修饰，上述代码必然导致堆栈被破坏，MFC在编译时插入的checkesp函数将告诉你，堆栈被破坏了。

DLL中调用约定和名称修饰- - 调用约定（Calling Convention）是指在程序设计语言中为了实现函数调用而建立的一种协议。这种协议规定了该语言的函数中的参数传送方式、参数是否可变和由谁来处理堆栈等问题。不同的语言定义了不同的调用约定。 在C++中，为了允许操作符重载和函数重载，C++编译器往往按照某种规则改写每一个入口点的符号名，以便允许同一个名字（具有不同的参数类型或者是不同的作用域）有多个用法，而不会打破现有的基于C的链接器。这项技术通常被称为名称改编（Name Mangling）或者名称修饰（Name Decoration）。许多C++编译器厂商选择了自己的名称修饰方案。 因此，为了使其它语言编写的模块（如Visual Basic应用程序、Pascal或Fortran的应用程序等）可以调用C/C++编写的DLL的函数，必须使用正确的调用约定来导出函数，并且不要让编译器对要导出的函数进行任何名称修饰。 1．调用约定（Calling Convention） 调用约定用来处理决定函数参数传送时入栈和出栈的顺序（由调用者还是被调用者把参数弹出栈），以及编译器用来识别函数名称的名称修饰约定等问题。在Microsoft VC++ 6.0中定义了下面几种调用约定，我们将结合汇编语言来一一分析它们： 1、__cdecl __cdecl是C/C++和MFC程序默认使用的调用约定，也可以在函数声明时加上__cdecl关键字来手工指定。采用__cdecl约定时，函数参数按照从右到左的顺序入栈，并且由调用函数者把参数弹出栈以清理堆栈。因此，实现可变参数的函数只能使用该调用约定。由于每一个使用__cdecl约定的函数都要包含清理堆栈的代码，所以产生的可执行文件大小会比较大。__cdecl可以写成_cdecl。 下面将通过一个具体实例来分析__cdecl约定： 在VC++中新建一个Win32 Console工程，命名为cdecl。其代码如下： int __cdecl Add(int a, int b); //函数声明 void main() { Add(1,2); //函数调用 } int __cdecl Add(int a, int b) //函数实现 { return (a + b); } 函数调用处反汇编代码如下： ;Add(1,2); push 2 ;参数从右到左入栈，先压入2 push 1 ;压入1 call @ILT+0(Add) (00401005) ;调用函数实现 add esp,8 ;由函数调用清栈 2、__stdcall __stdcall调用约定用于调用Win32 API函数。采用__stdcal约定时，函数参数按照从右到左的顺序入栈，被调用的函数在返回前清理传送参数的栈，函数参数个数固定。由于函数体本身知道传进来的参数个数，因此被调用的函数可以在返回前用一条ret n指令直接清理传递参数的堆栈。__stdcall可以写成_stdcall。 还是那个例子，将__cdecl约定换成__stdcall： int __stdcall Add(int a, int b) { return (a + b); } 函数调用处反汇编代码： ; Add(1,2); push 2 ;参数从右到左入栈，先压入2 push 1 ;压入1 call @ILT+10(Add) (0040100f) ;调用函数实现 函数实现部分的反汇编代码： ;int __stdcall Add(int a, int b) push ebp mov ebp,esp sub esp,40h push ebx push esi push edi lea edi,[ebp-40h] mov ecx,10h mov eax,0CCCCCCCCh rep stos dword ptr [edi] ;return (a + b); mov eax,dword ptr [ebp+8] add eax,dword ptr [ebp+0Ch] pop edi pop esi pop ebx mov esp,ebp pop ebp ret 8 ;清栈 3、__fastcall __fastcall约定用于对性能要求非常高的场合。__fastcall约定将函数的从左边开始的两个大小不大于4个字节（DWORD）的参数分别放在ECX和EDX寄存器，其余的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的堆栈。__fastcall可以写成_fastcall。 依旧是相类似的例子，此时函数调用约定为__fastcall，函数参数个数增加2个： int __fastcall Add(int a, double b, int c, int d) { return (a + b + c + d); } 函数调用部分的汇编代码： ;Add(1, 2, 3, 4); push 4 ;后两个参数从右到左入栈，先压入4 mov edx,3 ;将int类型的3放入edx push 40000000h ;压入double类型的2 push 0 mov ecx,1 ;将int类型的1放入ecx call @ILT+0(Add) (00401005) ;调用函数实现 函数实现部分的反汇编代码： ; int __fastcall Add(int a, double b, int c, int d) push ebp mov ebp,esp sub esp,48h push ebx push esi push edi push ecx lea edi,[ebp-48h] mov ecx,12h mov eax,0CCCCCCCCh rep stos dword ptr [edi] pop ecx mov dword ptr [ebp-8],edx mov dword ptr [ebp-4],ecx ;return (a + b + c + d); fild dword ptr [ebp-4] fadd qword ptr [ebp+8] fiadd dword ptr [ebp-8] fiadd dword ptr [ebp+10h] call __ftol (004011b8) pop edi pop esi pop ebx mov esp,ebp pop ebp ret 0Ch ;清栈 关键字__cdecl、__stdcall和__fastcall可以直接加在要输出的函数前，也可以在编译环境的Setting...->C/C++->Code Generation项选择。它们对应的命令行参数分别为/Gd、/Gz和/Gr。缺省状态为/Gd，即__cdecl。当加在输出函数前的关键字与编译环境中的选择不同时，直接加在输出函数前的关键字有效。 4、thiscall thiscall调用约定是C++中的非静态类成员函数的默认调用约定。thiscall只能被编译器使用，没有相应的关键字，因此不能被程序员指定。采用thiscall约定时，函数参数按照从右到左的顺序入栈，被调用的函数在返回前清理传送参数的栈，只是另外通过ECX寄存器传送一个额外的参数：this指针。 这次的例子中将定义一个类，并在类中定义一个成员函数，代码如下： class CSum { public: int Add(int a, int b) { return (a + b); } }; void main() { CSum sum; sum.Add(1, 2); } 函数调用部分汇编代码： ;CSum sum; ;sum.Add(1, 2); push 2 ;参数从右到左入栈，先压入2 push 1 ;压入1 lea ecx,[ebp-4] ;ecx存放了this指针 call @ILT+5(CSum::Add) (0040100a) ;调用函数实现 函数实现部分汇编代码： ;int Add(int a, int b) push ebp mov ebp,esp sub esp,44h ;多用了一个4bytes的空间用于存放this指针 push ebx push esi push edi push ecx lea edi,[ebp-44h] mov ecx,11h mov eax,0CCCCCCCCh rep stos dword ptr [edi] pop ecx mov dword ptr [ebp-4],ecx ;return (a + b); mov eax,dword ptr [ebp+8] add eax,dword ptr [ebp+0Ch] pop edi pop esi pop ebx mov esp,ebp pop ebp ret 8 ;清栈 5、naked属性 采用上面所述的四种调用约定的函数在进入函数时，编译器会产生代码来保存ESI、EDI、EBX、EBP寄存器中的值，退出函数时则产生代码恢复这些寄存器的内容。对于定义了naked属性的函数，编译器不会自动产生这样的代码，需要你手工使用内嵌汇编来控制函数实现中的堆栈管理。由于naked属性并不是类型修饰符，故必须和__declspec共同使用。下面的这段代码定义了一个使用了naked属性的函数及其实现： __declspec ( naked ) func() { int i; int j; _asm { push ebp mov ebp, esp sub esp, __LOCAL_SIZE } _asm { mov esp, ebp pop ebp ret } } naked属性与本节关系不大，具体请参考MSDN。 6、WINAPI 还有一个值得一提的是WINAPI宏，它可以被翻译成适当的调用约定以供函数使用。该宏定义于windef.h之中。下面是在windef.h中的部分内容： #define CDECL _cdecl #define WINAPI CDECL #define CALLBACK __stdcall #define WINAPI __stdcall #define APIENTRY WINAPI 由此可见，WINAPI、CALLBACK、APIENTRY等宏的作用。 2．名称修饰（Name Decoration） C或C++函数在内部（编译和链接）通过修饰名（Decoration Name）识别。函数的修饰名是编译器在编译函数定义或者原型时生成的字符串。编译器在创建.obj文件时对函数名称进行修饰。有些情况下使用函数的修饰名是必要的，如在模块定义文件里头指定输出C++重载函数、构造函数、析构函数，又如在汇编代码里调用C或C++函数等。 在VC++中，函数修饰名由编译类型（C或C++）、函数名、类名、调用约定、返回类型、参数等多种因素共同决定。下面分C编译、C++编译（非类成员函数）和C++类及其成员函数编译三种情况说明： 1、C编译时函数名称修饰 当函数使用__cdecl调用约定时，编译器仅在原函数名前加上一个下划线前缀，格式为_functionname。例如：函数int __cdecl Add(int a, int b)，输出后为：_Add。 当函数使用__stdcall调用约定时，编译器在原函数名前加上一个下划线前缀，后面加上一个@符号和函数参数的字节数，格式为_functionname@number。例如：函数int __stdcall Add(int a, int b)，输出后为：_Add@8。 当函数是用__fastcall调用约定时，编译器在原函数名前加上一个@符号，后面是加一个@符号和函数参数的字节数，格式为@functionname@number。例如：函数int __fastcall Add(int a, int b)，输出后为：@Add@8。 以上改变均不会改变原函数名中的字符大小写。 2、C++编译时函数（非类成员函数）名称修饰 当函数使用__cdecl调用约定时，编译器进行以下工作： 1．以?标识函数名的开始，后跟函数名； 2．函数名后面以@@YA标识开始，后跟返回值和参数表； 3．当函数的返回值或者参数与C++类无关的时候，返回值和参数表以下列代号表示： B：const D：char E：unsigned char F：short G：unsigned short H：int I：unsigned int J：long K：unsigned long M：float N：double _N：bool PA：指针（*，后面的代号表明指针类型，如果相同类型的指针连续出现，以0 代替，一个0代表一次重复） PB：const指针 AA：引用（&） AB：const引用 U：类或结构体 V：Interface（接口） W4：enum X：void 4、@@YA标识之后紧跟的是该函数的返回值类型，其后依次为参数的数据类型，指针标识在其所指数据类型前。当函数的返回值或者参数与C++类无关的时候，其处理符合本条规则，否则按照5、6规则处理； 5、当函数返回值为某个类或带有const性质的类的时候，返回值的命名为：?A/?B+V+类名+@@（不带加号）。当函数返回值为某个类的指针/引用或者带有const性质的类的指针/引用的时候，返回值的命名为：PA/AA或者PB/AB+V+类名+@@（不带加号）； 6、函数参数为某个类的时候，并且该参数所使用的类曾经出现过的话（也就是与函数返回值所使用的类相同或者与前一个参数使用的类相同），则该参数类型格式为：V+1+@（不带加号）。如果该参数所使用的类没有出现过的话，则该参数类型格式为：V+类名+@@（不带加号）。函数参数为某个类的指针/引用或者带有const性质指针/引用的时候，则该参数类型格式是在上述格式的基础上在V前面加上代表指针/引用类型或者带有const性质指针/引用类型的标识符（PA/AA或PB/AB）； 7、参数表后以@Z标识整个名字的结束，如果该函数无参数，则以Z标识结束。 当函数使用__stdcall调用约定时，编译器所做工作的规则同上面的__cdecl调用约定，只是参数表的开始标识由上面的@@YA变为@@YG。 当函数使用__fastcall调用约定时，编译器所做工作的规则同上面的__cdecl调用约定，只是参数表的开始标识由上面的@@YA变为@@YI。 3、C++编译类及其成员函数时名称修饰 对于导出的C++类，仅能使用__cdecl调用约定。在编译器编译过程中，编译器会对C++类进行处理。如：class __declspec(dllexport) MyClass会被处理为class MyClass & MyClass::operator=(class MyClass const &)。在C++编译器对C++类进行名称修饰的时候，编译器进行以下工作： 1．以?标识函数名的开始，后跟?4+类名； 2．类名后面跟@@QAE标识，对于导出类来说这是固定的； 3．@@QAE后面跟AAV0@ABV0@，即引用类型标识符AA+V+0（重复的类的标识符）+@（不带加号）和const性质的引用AB+V+ 0（重复的类的标识符）+@（不带加号）； 4．最后以@Z标识整个名字的结束。 对于导出的C++类中的成员函数（非构造函数和析构函数），可以使用不同的调用约定。当导出的C++类中的成员函数使用__cdecl调用约定时，编译器进行以下工作： 1．以?标识函数名的开始，后跟函数名+@+类名（不带加号）； 2．之后以@@QAE标识开始，后跟返回值和参数表； 3．当函数的返回值或者参数与C++类无关的时候，返回值和参数表以下列代号表示： B：const D：char E：unsigned char F：short G：unsigned short H：int I：unsigned int J：long K：unsigned long M：float N：double _N：bool PA：指针（*，后面的代号表明指针类型，如果相同类型的指针连续出现，以0 代替，一个0代表一次重复） PB：const指针 AA：引用（&） AB：const引用 U：类或结构体 V：Interface（接口） W4：enum X：void 4、@@QAE标识之后紧跟的是该函数的返回值类型，其后依次为参数的数据类型，指针标识在其所指数据类型前。当函数的返回值或者参数与C++类无关的时候，其处理符合本条规则，否则按照5、6规则处理； 5、当函数返回值为当前类或带有const性质的当前类的时候，返回值的命名为：?A或?B+V+1+@@（不带加号）。当函数返回值为当前类的指针/引用或者带有const性质的当前类的指针/引用的时候，返回值的命名为：PA/AA或PB/AB+V+1+@@（不带加号）； 6、当函数返回值为某个类或带有const性质的类的时候，返回值的命名为：?A/?B+V+类名+@@（不带加号）。当函数返回值为某个类的指针/引用或者带有const性质的类的指针/引用的时候，返回值的命名为：PA/AA或者PB/AB+V+类名+@@（不带加号）； 7、函数参数为某个类的时候，并且该参数所使用的类曾经出现过的话（也就是当前要导出的类、与函数返回值所使用的类相同或者与前一个参数使用的类相同的类），则该参数类型格式为：V+1+@（不带加号）。如果该参数所使用的类不是当前要导出的类的话，则该参数类型格式为：V+类名+@@（不带加号）。函数参数为某个类的指针/引用或者带有const性质指针/引用的时候，则该参数类型格式是在上述格式的基础上在V前面加上代表指针/引用类型或者带有const性质指针/引用类型的标识符（PA/AA或PB/AB）； 8、参数表后以@Z标识整个名字的结束，如果该函数无参数，则以Z标识结束。 当函数使用__stdcall调用约定时，编译器所做工作的规则同上面的__cdecl调用约定，只是参数表的开始标识由上面的@@YA变为@@YG。 当函数使用__fastcall调用约定时，编译器所做工作的规则同上面的__cdecl调用约定，只是参数表的开始标识由上面的@@YA变为@@YI。 4、C++编译导出数据时名称修饰 对于导出的数据，仅使用__cdecl调用约定。在C++编译器对C++类进行名称修饰的时候，编译器进行以下工作： 1．以?标识数据的开始，后跟数据名； 2．数据名后面以@@3标识开始，后跟数据类型； 3．当数据类型与C++类无关的时候，数据类型以下列代号表示： B：const D：char E：unsigned char F：short G：unsigned short H：int I：unsigned int J：long K：unsigned long M：float N：double _N：bool PA：指针（*，后面的代号表明指针类型，如果相同类型的指针连续出现，以0 代替，一个0代表一次重复） PB：const指针 AA：引用（&） AB：const引用 U：类或结构体 V：Interface（接口） W4：enum X：void 4．如果数据类型是某个类的时候，数据类型的命名为：V+类名+@@（不带加号）。当数据类型为当前类的指针/引用或者带有const性质的当前类的指针/引用的时候，数据类型的命名为：PA/AA或PB/AB+V+类名+@@（不带加号）； 5．最后，如果数据类型是const性质，则修饰名以B结尾。如果数据类型是非const性质，则修饰名以A结尾。