[ZZ]剖析VC++函数调用约定

最新推荐文章于 2024-09-18 21:46:14 发布
最新推荐文章于 2024-09-18 21:46:14 发布
阅读量1k 收藏
点赞数
文章标签： vc++ c++ c winapi library 编译器

  原文链接：http://blog.csdn.net/goodname008/archive/2004/07/24/50662.aspx

  原文作者：卢培培（goodname008）  

Visual C/C++ 的编译器提供了几种函数调用约定，了解这些函数调用约定的含义及它们之间的区别可以帮助我们更好地调试程序。在这篇文章里，我就和大家共同探讨一些关于函数调用约定的内容。
     Visual C/C++ 的编译器支持如下的函数调用约定：
 
关键字
清理堆栈
参数入栈顺序
函数名称修饰(C)
__cdecl
调用函数
右 à 左
_ 函数名
__stdcall
被调用函数
右 à 左
_ 函数名@数字
__fastcall
被调用函数
右 à 左
@ 函数名@数字
thiscall( 非关键字)
被调用函数
右 à 左
/
 
     上面这张表只简单地列出了每种函数调用约定的特点，既然这篇文章题目的前两个字是“剖析”，哪能这么容易就完事！？下面就对上面这四种函数调用约定逐个“剖析”：
     一、__cdecl函数调用约定
     这是C和C++ 程序默认的函数调用约定，参数按从右到左的顺序压入堆栈，由调用函数负责清理堆栈，把参数弹出栈。也正是因为用来传送参数的堆栈是由调用函数维护的，所以实现可变参数的函数只能使用这种函数调用约定。因为每一个调用它的函数都要包含清理堆栈的代码，所以编译后的可执行文件的大小要比调用__stdcall函数的大。使用这种函数调用约定时，修饰后的函数名只是在原函数名前加上了一个_（下划线），并且不改变函数的大小写。对于__cdecl，我们一般不特别指出，因为它是C和C++ 程序默认的函数调用约定，所以只有将编译选项设置成/Gz（stdcall）或/Gr（fastcall）时，我们才有必要在函数名前显式地指出采用这种函数调用约定。下面举一个例子：
 
int __cdecl Sumcdecl(int a, int b, int c)
{
int i = 1000;
short j = 2000;
int k = 3000;
int rEBP = 0;
int value = 0;
 
// ...
 
return (a + b + c);
 
}
 
调用：Sumcdecl(10, 20, 30);
 
 
函数体及调用语句如上所示，修饰后的函数名为_Sumcdecl，堆栈和寄存器状态如下（一行表示4个字节）：
 
0
 value
0
 rEBP
3000
 k
2000
 j
1000
 i
　
 <---------EBP
　
 
10
 a
20
 b
30
 c
　
 
[ 未使用]
 ECX
[ 未使用]
 EDX
 
     口说无凭，代码能说明一切，下面的程序乃Win32 console application（.exe）是也：
 
#include "iostream.h"
#include "stdio.h"
 
extern "C" __declspec(dllexport) int __cdecl Sumcdecl(int a, int b, int c)
{
// 声明局部变量
     int i = 1000;
     short j = 2000;
     int k = 3000;
     int rEBP = 0;
     int value = 0;
 
     // 显示局部变量的地址
     cout << " 局部变量的地址:" << endl;
     cout << &value << "    <-----------value" << endl;
     cout << &rEBP << "    <-----------rEBP" << endl;
     cout << &k << "    <-----------k" << endl;
     cout << &j << "    <-----------j" << endl;
     cout << &i << "    <-----------i" << endl;
 
     // 显示寄存器的值
     cout << " 寄存器:" << endl;
     __asm mov rEBP, ebp;
     printf("0x%08X    <-----------EBP/n", rEBP);
 
     // 显示函数参数的地址
     cout << " 函数参数的地址:" << endl;
     cout << &a << "    <-----------a" << endl;
     cout << &b << "    <-----------b" << endl;
     cout << &c << "    <-----------c" << endl;
 
     // 通过 EBP 寄存器获得堆栈中的数据并显示
     cout << " 通过EBP获取堆栈中的数据:" << endl;
     __asm mov eax, [ebp - 4];
     __asm mov value, eax;
     cout << "i: " << value << endl;
 
     __asm mov eax, [ebp - 8];
     __asm mov value, eax;
     cout << "j: " << (short)value << endl;
 
     __asm mov eax, [ebp - 12];
     __asm mov value, eax;
     cout << "k: " << value << endl;
 
     __asm mov eax, [ebp + 8];
     __asm mov value, eax;
     cout << "a: " << value << endl;
 
     __asm mov eax, [ebp + 12];
     __asm mov value, eax;
     cout << "b: " << value << endl;
 
     __asm mov eax, [ebp + 16];
     __asm mov value, eax;
     cout << "c: " << value << endl;
 
     // 返回
     return (a + b + c);
 
}
 
// 主函数
int main(int argc, char* argv[])
{
 
     Sumcdecl(10, 20, 30);
 
     return 0;
 
}
 
 
     在我的机器上，运行结果如下：
 
局部变量的地址:
0x0012FF0C    <-----------value
0x0012FF10    <-----------rEBP
0x0012FF14    <-----------k
0x0012FF18    <-----------j
0x0012FF1C    <-----------i
寄存器:
0x0012FF20    <-----------EBP
函数参数的地址:
0x0012FF28    <-----------a
0x0012FF2C    <-----------b
0x0012FF30    <-----------c
通过EBP获取堆栈中的数据:
i: 1000
j: 2000
k: 3000
a: 10
b: 20
c: 30
 
     函数声明部分的extern “C”表示连接规范（Linkage Specification）采用C，而不是C++，不加extern “C”的情况我会在后面统一讨论。__declspec(dllexport)表示将该函数导出，将生成.lib文件，以便我们验证函数名是怎样修饰的。关于修饰后的函数名，我们可以使用VC98/bin目录下的dumpbin工具来验证：
 
     dumpbin /exports 文件名>
 
     输出结果如下：
 
File Type: LIBRARY
 
     Exports
 
       ordinal    name
 
                  _Sumcdecl
 
 Summary
 
          C9 .debug$S
          14 .idata$2
          14 .idata$3
           4 .idata$4
           4 .idata$5
           E .idata$6
 
     二、__stdcall函数调用约定
     __stdcall 函数调用约定通常用于Win32 API函数，参数按从右到左的顺序压入堆栈，由被调用函数负责清理堆栈，把参数弹出栈。在windows.h中包含了windef.h，而windef.h中定义了一个WINAPI宏：#define WINAPI __stdcall，呵呵，应该心知肚明了。使用这种函数调用约定时，修饰后的函数名在原函数名前加上了一个_（下划线），并且在原函数名后加上“@数字”，当然也不改变函数的大小写，@ 后面的数字表示参数所占的字节数，这里有一点要注意的，不足32位（4字节）的参数将在参数传递时被扩充到32位。下面举一个例子：
 
int __stdcall Sumstdcall(int a, int b, int c)
{
int i = 1000;
short j = 2000;
int k = 3000;
int rEBP = 0;
int value = 0;
 
// ...
 
return (a + b + c);
 
}
 
调用：Sumstdcall(10, 20, 30);
 
 
     函数体及调用语句如上所示，修饰后的函数名为_Sumstdcall@12，int是32位的，占4个字节，3个32位的变量，共12个字节。堆栈和寄存器状态如下（一行表示4个字节）：
 
0
 value
0
 rEBP
3000
 k
2000
 j
1000
 i
　
 <---------EBP
　
 
10
 a
20
 b
30
 c
　
 
[ 未使用]
 ECX
[ 未使用]
 EDX
 
 
     仍然以代码说明：
 
#include "iostream.h"
#include "stdio.h"
 
extern "C" __declspec(dllexport) int __stdcall Sumstdcall(int a, int b, int c)
{
     // 声明局部变量
     int i = 1000;
     short j = 2000;
     int k = 3000;
     int rEBP = 0;
     int value = 0;
 
     // 显示局部变量的地址
     cout << " 局部变量的地址:" << endl;
     cout << &value << "    <-----------value" << endl;
     cout << &rEBP << "    <-----------rEBP" << endl;
     cout << &k << "    <-----------k" << endl;
     cout << &j << "    <-----------j" << endl;
     cout << &i << "    <-----------i" << endl;
 
     // 显示寄存器的值
     cout << " 寄存器:" << endl;
     __asm mov rEBP, ebp;
     printf("0x%08X    <-----------EBP/n", rEBP);
 
     // 显示函数参数的地址
     cout << " 函数参数的地址:" << endl;
     cout << &a << "    <-----------a" << endl;
     cout << &b << "    <-----------b" << endl;
     cout << &c << "    <-----------c" << endl;
 
     // 通过 EBP 寄存器获得堆栈中的数据并显示
     cout << " 通过EBP获取堆栈中的数据:" << endl;
     __asm mov eax, [ebp - 4];
     __asm mov value, eax;
     cout << "i: " << value << endl;
 
     __asm mov eax, [ebp - 8];
     __asm mov value, eax;
     cout << "j: " << (short)value << endl;
 
     __asm mov eax, [ebp - 12];
     __asm mov value, eax;
     cout << "k: " << value << endl;
 
     __asm mov eax, [ebp + 8];
     __asm mov value, eax;
     cout << "a: " << value << endl;
 
     __asm mov eax, [ebp + 12];
     __asm mov value, eax;
     cout << "b: " << value << endl;
 
     __asm mov eax, [ebp + 16];
     __asm mov value, eax;
     cout << "c: " << value << endl;
 
     // 返回
     return (a + b + c);
    
}
 
// 主函数
int main(int argc, char* argv[])
{
 
     Sumstdcall(10, 20, 30);
 
     return 0;
 
}
 
 
在我的机器上，运行结果如下：
 
局部变量的地址:
0x0012FF0C    <-----------value
0x0012FF10    <-----------rEBP
0x0012FF14    <-----------k
0x0012FF18    <-----------j
0x0012FF1C    <-----------i
寄存器:
0x0012FF20    <-----------EBP
函数参数的地址:
0x0012FF28    <-----------a
0x0012FF2C    <-----------b
0x0012FF30    <-----------c
通过EBP获取堆栈中的数据:
i: 1000
j: 2000
k: 3000
a: 10
b: 20
c: 30
 
     其实和__cdecl的差不多，只是把__cdecl改成了__stdcall，又换了个函数名。用dumpbin分析.lib文件的结果如下：
 
File Type: LIBRARY
 
     Exports
 
       ordinal    name
 
                  _Sumstdcall@12
 
 Summary
 
          C9 .debug$S
          14 .idata$2
          14 .idata$3
           4 .idata$4
           4 .idata$5
           E .idata$6
 
     三、__fastcall函数调用约定
     __fastcall ，顾名思义，特点就是快，因为它是靠寄存器来传递参数的。传递参数时，最左边的两个小于等于32位（4字节）的参数将被分别存入ECX和EDX寄存器，其余参数仍然按从右到左的顺序压入堆栈，由被调用函数负责清理堆栈，把参数弹出栈。这里有一点想强调一下：存入寄存器的那两个参数实际也存入到了堆栈中，后面的例子和代码将证明这一点。使用这种函数调用约定时，修饰后的函数名在原函数名前加上了一个 @，并且在原函数名后加上“@数字”，同样不改变函数的大小写，@ 后面的数字表示参数所占的字节数，其实和__stdcall差不多，只是把最前面的_（下划线）换成了@。下面举一个例子，和前面两个稍有不同：
 
int __fastcall Sumfastcall(int a, double x, int b, int c)
{
     int i = 1000;
     short j = 2000;
     int k = 3000;
     int rEBP = 0;
     int rECX = 0;
     int rEDX = 0;
     int value = 0;
 
// ...
 
return (a + b + c);
 
}
 
调用：Sumfastcall(10, 8.8, 20, 30);
 
 
     函数体及调用语句如上所示，修饰后的函数名为@Sumfastcall@20，int是32位的，占4个字节，double是64位的，占8个字节，3个32位的变量加1个64位的变量，共20个字节。堆栈和寄存器状态如下（一行表示4个字节）：
 
0
 value
0
 rEDX
0
 rECX
0
 rEBP
3000
 k
2000
 j
1000
 i
20
 b
10
 a
　
 <---------EBP
　
 
8.8
 x （8个字节）
30
 c
 
 
10
 ECX
20
 EDX
 
     由于__fastcall和前面两个函数调用约定不太一样，局部变量、函数参数在堆栈中的存放情况和寄存器（主要是ECX和EDX）中的值都有了变化，这些我们都要验证，因此代码也不一样，但大体相同，下面就将它们请出来：
 
#include "iostream.h"
#include "stdio.h"
 
extern "C" __declspec(dllexport) int __fastcall Sumfastcall(int a, double x, int b, int c)
{
     // 声明局部变量
     int i = 1000;
     short j = 2000;
     int k = 3000;
     int rEBP = 0;
     int rECX = 0;
     int rEDX = 0;
     int value = 0;
 
     // 显示 ECX 和 EDX 寄存器的值
     __asm mov rECX, ecx;
     __asm mov rEDX, edx;
     cout << "ECX 和 EDX 寄存器的值:" << endl;
     cout << "ECX: " << rECX << endl;
     cout << "EDX: " << rEDX << endl;
 
     // 显示局部变量的地址
     cout << " 局部变量的地址:" << endl;
     cout << &value << "    <-----------value" << endl;
     cout << &rEDX << "    <-----------rEDX" << endl;
     cout << &rECX << "    <-----------rECX" << endl;
     cout << &rEBP << "    <-----------rEBP" << endl;
     cout << &k << "    <-----------k" << endl;
     cout << &j << "    <-----------j" << endl;
     cout << &i << "    <-----------i" << endl;
 
     // 显示存入寄存器的参数的地址, 变量虽然存入了寄存器, 但也在堆栈中
     cout << " 显示存入寄存器的参数的地址:" << endl;
     cout << &b << "    <-----------b" << endl;
     cout << &a << "    <-----------a" << endl;
 
     // 显示寄存器的值
     cout << " 寄存器:" << endl;
     __asm mov rEBP, ebp;
     printf("0x%08X    <-----------EBP/n", rEBP);
 
     // 显示函数参数的地址
     cout << " 函数参数的地址:" << endl;
     cout << &x << "    <-----------x" << endl;
     cout << &c << "    <-----------c" << endl;
 
     // 通过 EBP 寄存器获得堆栈中的数据并显示
     cout << " 通过EBP获取堆栈中的数据:" << endl;
     __asm mov eax, [ebp - 12];
     __asm mov value, eax;
     cout << "i: " << value << endl;
    
     __asm mov eax, [ebp - 16];
     __asm mov value, eax;
     cout << "j: " << (short)value << endl;
 
     __asm mov eax, [ebp - 20];
     __asm mov value, eax;
     cout << "k: " << value << endl;
 
     __asm mov eax, [ebp - 4];
     __asm mov value, eax;
     cout << "a: " << value << endl;
 
     __asm mov eax, [ebp - 8];
     __asm mov value, eax;
     cout << "b: " << value << endl;
 
     __asm mov eax, [ebp + 16];
     __asm mov value, eax;
     cout << "c: " << value << endl;
 
     // 返回
     return (a + b + c);
    
}
 
// 主函数
int main(int argc, char* argv[])
{
 
     Sumfastcall(10, 8.8, 20, 30);
 
     return 0;
 
}
 
 
在我的机器上，运行结果如下：
 
ECX 和 EDX 寄存器的值:
ECX: 10
EDX: 20
局部变量的地址:
0x0012FEFC    <-----------value
0x0012FF00    <-----------rEDX
0x0012FF04    <-----------rECX
0x0012FF08    <-----------rEBP
0x0012FF0C    <-----------k
0x0012FF10    <-----------j
0x0012FF14    <-----------i
显示存入寄存器的参数的地址:
0x0012FF18    <-----------b
0x0012FF1C    <-----------a
寄存器:
0x0012FF20    <-----------EBP
函数参数的地址:
0x0012FF28    <-----------x
0x0012FF30    <-----------c
通过EBP获取堆栈中的数据:
i: 1000
j: 2000
k: 3000
a: 10
b: 20
c: 30
 
     同样使用dumpbin /exports后结果如下：
 
File Type: LIBRARY
 
     Exports
 
       ordinal    name
 
                  @Sumfastcall@20
 
 Summary
 
          C9 .debug$S
          14 .idata$2
          14 .idata$3
           4 .idata$4
           4 .idata$5
           E .idata$6
 
     四、thiscall函数调用约定
     咦？thiscall前面怎么没有下划线，呵呵。事实上，thiscall并不是C++ 的关键字，所以我们不能在程序中显式地指出采用这种函数调用约定。可能有人会问了，那这东西到底怎么用？其实，我们经常都在用，因为它是C++ 成员函数默认的函数调用约定，参数按从右到左的顺序压入堆栈，由被调用函数负责清理堆栈，把参数弹出栈。在秘密传递this指针时，成员函数不仅将this指针存入到了ECX寄存器中，而且也存入到了堆栈中，但却是最后压入到堆栈，位置和采用__fastcall调用约定的函数的最左边的两个小于等于32位（4字节）的参数的位置相同。下面举一个例子：
 
class Test
{
public :
     int Sumthiscall(int a, int b, int c)
     {
         int i = 1000;
         short j = 2000;
         int k = 3000;
         int rEBP = 0;
         int value = 0;
 
         // ...
 
         return (a + b + c);
 
     }
 
};
 
调用：
Test test;
test.Sumthiscall(10, 20, 30);
 
 
成员函数的定义及调用语句如上所示，堆栈和寄存器状态如下（一行表示4个字节）：
 
0
 value
0
 rEBP
3000
 k
2000
 j
1000
 i
对象地址
 this
　
 <---------EBP
　
 
10
 a
20
 b
30
 c
 
 
对象地址
 ECX
[ 未使用]
 EDX
 
     下面我们还是让代码说话，我最相信它了：
 
#include "iostream.h"
#include "stdio.h"
 
class Test
{
public :
     int Sumthiscall(int a, int b, int c)
     {
         // 声明局部变量
         int i = 1000;
         short j = 2000;
         int k = 3000;
         int rEBP = 0;
         int value = 0;
        
         // 通过 ECX 寄存器获得 this 指针
         __asm mov value, ecx;
         printf(" 通过ECX 寄存器获得 this 指针: 0x%08X/n", value);
        
         // 直接输出 this 所指对象的地址
         printf(" 直接输出 this 所指对象的地址: 0x%08X/n", this);
        
         // 显示局部变量的地址
         cout << " 局部变量的地址:" << endl;
         cout << &value << "    <-----------value" << endl;
         cout << &rEBP << "    <-----------rEBP" << endl;
         cout << &k << "    <-----------k" << endl;
         cout << &j << "    <-----------j" << endl;
         cout << &i << "    <-----------i" << endl;
 
         // 显示寄存器的值
         cout << " 寄存器:" << endl;
         __asm mov rEBP, ebp;
         printf("0x%08X    <-----------EBP/n", rEBP);
 
         // 显示函数参数的地址
         cout << " 函数参数的地址:" << endl;
         cout << &a << "    <-----------a" << endl;
         cout << &b << "    <-----------b" << endl;
         cout << &c << "    <-----------c" << endl;
 
         // 通过 EBP 寄存器获得堆栈中的数据并显示
         cout << " 通过EBP获取堆栈中的数据:" << endl;
         __asm mov eax, [ebp - 4];
         __asm mov value, eax;
         printf("this: 0x%08X/n", value);
 
         __asm mov eax, [ebp - 8];
         __asm mov value, eax;
         cout << "i: " << value << endl;
 
         __asm mov eax, [ebp - 12];
         __asm mov value, eax;
         cout << "j: " << (short)value << endl;
 
         __asm mov eax, [ebp - 16];
         __asm mov value, eax;
         cout << "k: " << value << endl;
 
         __asm mov eax, [ebp + 8];
         __asm mov value, eax;
         cout << "a: " << value << endl;
 
         __asm mov eax, [ebp + 12];
         __asm mov value, eax;
         cout << "b: " << value << endl;
 
         __asm mov eax, [ebp + 16];
         __asm mov value, eax;
         cout << "c: " << value << endl;
 
         // 返回
         return (a + b + c);
 
     }
 
};
 
// 主函数
int main(int argc, char* argv[])
{
     Test test;
     test.Sumthiscall(10, 20, 30);
 
     return 0;
 
}
 
     在我的机器上，运行结果如下：
 
通过ECX 寄存器获得 this 指针: 0x0012FF7C
直接输出 this 所指对象的地址: 0x0012FF7C
局部变量的地址:
0x0012FF04    <-----------value
0x0012FF08    <-----------rEBP
0x0012FF0C    <-----------k
0x0012FF10    <-----------j
0x0012FF14    <-----------i
寄存器:
0x0012FF1C    <-----------EBP
函数参数的地址:
0x0012FF24    <-----------a
0x0012FF28    <-----------b
0x0012FF2C    <-----------c
通过EBP获取堆栈中的数据:
this: 0x0012FF7C
i: 1000
j: 2000
k: 3000
a: 10
b: 20
c: 30
 
     代码中没有通过输出this指针变量所在的地址（存在&this吗？）来验证它是否被存入到堆栈中，但却通过EBP寄存器正确获得了this所指对象的地址，和ECX寄存器中的值一样。因为thiscall函数调用约定只应用于C++ 类的成员函数，所以不存在C语言函数名称修饰机制，因此我没有讨论它，也没有将成员函数导出。
 
     Sumcdecl 、Sumstdcall和Sumfastcall三个函数前都有个extern “C”，表示连接规范（Linkage Specification）采用C，而不是C++，如果不写的话默认采用C++，当然也可以写成extern “C++”。把这3个函数放到一个文件中，并去掉每个函数前面的extern “C”，编译后用dumpbin分析.lib文件，结果如下（我只取了关键部分）：
 
 ?Sumcdecl@@YAHHHH@Z (int __cdecl Sumcdecl(int,int,int))
?Sumfastcall@@YIHHNHH@Z (int __fastcall Sumfastcall(int,double,int,int))
 ?Sumstdcall@@YGHHHH@Z (int __stdcall Sumstdcall(int,int,int))
 
哇！？这都是些什么东西啊，看上去好像有点乱，且听在下慢慢道来：
     1 、每个函数都是以“?”开头，接着是函数名，不改变大小写。
     2 、对于__cdecl，函数名后接@@YA；对于__stdcall，函数名后接@@YG；对于__fastcall，函数后接@@YI。
     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
O
long double
PA
指针前缀
AA
引用前缀
V 类名@@
类
 
     如果某个参数是指针，则在类型代号前加上PA；如果是引用，则在类型代号前加上AA。如果相同类型的指针连续出现，则以“0”代替，每个“0”都代表一次重复；如果相同类型的引用连续出现，则以“1”代替，每个“1”都代表一次重复。
     4 、代号列表后接@Z或Z来标识整个函数名的结束：如果该函数有参数，则以@Z标识函数名结束；如果该函数没有参数，则以Z标识函数名结束。
     5 、函数名结束标志后接一个空格，空格后是带括号的函数原型。在生成的最终文件（.exe或.dll）中，函数名结束标志后面将不会有函数原型。
 
     举个简单的例子，假设函数原型如下（Test为自定义类）：
void abc(int a, long b, char* c, char* d, bool &e, Test f, short g)
那么，修饰后的函数名为：
?abc@@YAXHJPAD0AA_NVTest@@F@Z
 
其实，我们可以在VC++ 6.0的IDE环境中设置当前工程采用的默认函数调用约定。在主界面下按 Alt + F7 打开【Project Settings】对话框，选择【C/C++】选项卡，然后在【Category】下拉列表框中选择“Code Gernation”，就可以在【Call convetion】下拉列表框中选择函数调用约定了。至于命令行开关，/Gd表示__cdecl，/Gr表示__fastcall，/Gz表示__fastcall。
 
最后还有一个小插曲，和这篇文章的主题没太大关系，但细心的人一定会发现这个问题。上面提到的所有函数（包括Test类的成员函数），局部变量j都是short型的，应该只占2个字节，但从内存分配情况来看却占了4个字节，为什么呢？因为内存分配的最小单位是4个字节。不信可以char s[10]，再使用和上面类似的方法分析一下，我们都认为占10个字节天经地义，但事实上，有12个字节是分给它的。
 
     好了，本次旅途到此结束，希望您旅途愉快。最后再送上一个小礼物：我把上面的Test类和其余3个函数放到了一个文件中，将所有例子综合到了一起：
znnren
关注
C++中的函数签名 (Function Signature)
2301_77727857的博客
05-27 704
函数签名是函数在程序中唯一标识其的一个部分。它包括函数的名称和参数列表（参数的类型和顺序）。在某些编程语言中，函数签名也可能包括返回类型，但在C++中，返回类型不是函数签名的一部分。
C/C++ 函数签名与名字修饰（符号修饰）
回首愁的博客
04-13 8410
名字修饰和extern "C"
php扩展调用php函数,怎么在扩展里调用PHP函数呢
weixin_42550614的博客
03-09 217
如何在扩展里调用PHP函数呢?声明：本文为斯人原创，全部为作者一一分析得之，有不对的地方望赐教。欢迎转载，转载请注明出处 。本文地址：http://imsiren.com/archives/606在写扩展的时候，肯定不能什么功能都自己实现，原因有很多，开发效率、性能问题、维护成本等。这就避免不了要在扩展里调用PHP内核函数。那么如何在扩展里面使用我们的内置函数呢？PHP既然有函数，肯定提供了调用函...
函数调用真题分析详解
m0_64963726的博客
03-14 515
用一个案列，来分析函数调用。
c++中类的成员函数调用剖析
不积跬步无以至千里
05-08 3404
此用一个小示例来说明c++中成员函数是怎么调用的
C++中记录并解析函数调用栈callstack
halazi100
07-13 2762
glibc中提供了backtrace()和backtrace_symbols()两个函数来输出和解析程序的call stack, 输出程序运行时调用栈信息 可以通过命令man backtrace查看具体帮忙信息。 #include <execinfo.h> int backtrace(void **buffer, int size); char **backtrace_symbols(void *const *buffer, int size); 使用backtrace()函数获取调用栈
Java代码调用HTML5中的JS函数算法
随笔日志
12-22 8036
随着HTML5的普及，越来越多的APP客户端逻辑开始使用HTML5来构造。甚至有些APP不仅将展示页面使用HTML5布局，还将一些关键字符串的加密算法写在了JS脚本中。一些是客户端自定义的算法，可能一时难以完全读懂直接重写，如果能像smali代码中的方法那样直接调用就好了，所以下面分享几种Java代码直接调用JS方法的。 1.Java代码内写JS方法 简单示例：     // JSFunti
zz：虚函数绑定与调用时机分析
jtujtujtu的专栏
03-10 1023
<br />zz: http://bbs.chinaunix.net/archiver/tid-1711337.html<br /> <br />理解虚函数( virtual function )的几个关键点：<br /> 1.       理解早绑定(early binding)、晚绑定(late binding)。所谓early binding：On compile time，就能明确一个函数调用是对哪个对象的哪个成员函数进行的，即编译时就晓得了确定的函数地址；所谓late binding：O
linux c sync函数,怎么在Linux中调用fsync函数
weixin_33587731的博客
05-03 672
Linux中如何调用fsync函数？针对这个问题，本文详细介绍了相应的分析和解决方法，希望能帮助更多想解决这个问题的伙伴找到更简单易行的方法。功能描述：将内存中所有已修改的文件数据同步到存储设备。用法：#包含unistd.hint fsync(int FD)；参数：文件描述符。回到描述：成功执行后，它返回0。失败返回-1，errno设置为下列值之一无效的文件描述符EIO:读写时出错文件所在的文...
MATLAB算法主成分分析降维代码直接调用版
04-15
3. 调用函数：使用MATLAB中的`pca`函数进行主成分分析。 4. 分析结果：根据函数返回的主成分进行分析，决定需要保留的主成分数量，以及降维后的数据集。 在本例中，代码直接调用版的含义可能是指，用户不需要编写...
实例MATLAB信号处理频谱分析加汉宁窗函数源代码
04-14
根据提供的信息，这篇文档讲述了如何在MATLAB环境下进行信号处理和频谱分析，同时应用汉宁窗函数。以下内容将详细介绍这些知识点： ### MATLAB软件概述 MATLAB（Matrix Laboratory的简称）是一款由MathWorks公司...
【专家独推】全网最全Matlab常用函数（包括按首字母进行分类）
热门推荐
左手の明天的博客
03-30 3万+
目录 1、求组合数 2、求阶乘 3、求全排列 4、求指数 5、求行列式 6、求矩阵的转置 7、求向量的指数 8、求自然对数 9、求矩阵的逆矩阵 10、多项式的乘法运算 11、多项式除法 12、求一个向量的最大值 13、求矩阵的最大值和最小值 14、求和与求积 15、平均值、标准方差 16、相关系数 17、排序 18、多项式的求导 19、多项式的求值 20、常用的基本数学函数 21、常用的三角函数 22、适用于向量的常用函数 23、MATLAB的永久常数 24、
C++ STL中sort函数
weixin_43349440的博客
09-15 374
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1171
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
qq_74190237的博客
09-13 305
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
标准C++（二）
最新发布
m0_63127040的博客
09-18 425
在C语言中定义的全局变量、函数、结构、联合、枚举、枚举值、宏都在全局作用域下，所以当项目比较庞大时，非常容易造成命名冲突（以模块名作前缀、后缀），所以C++中选择把全局作用域进行拆分成子作用域进行管理，这些子作用域就是作名字空间。把抽象结果（利用面向对象的思维模式，思考、观察出的结果），使用用C++的语法封装出一种类似结构的自定义数据类型（复合数据类型）。使用设计好的类（结构）这种数据类型，定义出的类变量在面向对象编程语言中被称为对象（结构变量），创建类对象的行为也被称为实例化对象。int id;
CCF201903_1
m0_67663419的博客
09-14 234
【代码】CCF201903_1。
C++笔记---模板进阶
2302_80372340的博客
09-13 939
【优点】1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生2. 增强了代码的灵活性【缺陷】1. 模板会导致代码膨胀问题，也会导致编译时间变长2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误。
递归算法设计：尾递归与主定理的应用示例
首先，递归定义了过程或函数调用自己的行为，分为直接递归和间接递归。【例2.1】给出了求阶乘n!的递归函数，它是直接递归且尾递归的形式，即递归调用是函数执行的最终步骤。递归算法通常适用于满足以下三个条件的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值