self

Ｃ语言中函数参数的入栈顺序
分类： linux编程 2011-03-08 10:06 79人阅读 评论(0) 收藏 举报
对技术执着的人，比如说我，往往对一些问题，不仅想做到“知其然”，还想做到“知其所以然”。Ｃ语言可谓博大精深，即使我已经有多年的开发经验，可还是有许多问题不知其所以然。某天某地某人问我，Ｃ语言中函数参数的入栈顺序如何？从右至左，我随口回答。为什么是从右至左呢？我终究没有给出合理的解释。于是，只好做了个作业，于是有了这篇小博文。

#include <stdio.h>

void foo(int x, int y, int z)
{
        printf("x = %d at [%X]/n", x, &x);
        printf("y = %d at [%X]/n", y, &y);
        printf("z = %d at [%X]/n", z, &z);
}

int main(int argc, char *argv[])
{
        foo(100, 200, 300);
        return 0;
}

运行结果：
x = 100 at [BFE28760]
y = 200 at [BFE28764]
z = 300 at [BFE28768]

Ｃ程序栈底为高地址，栈顶为低地址，因此上面的实例可以说明函数参数入栈顺序的确是从右至左的。可到底为什么呢？查了一直些文献得知，参数入栈顺序是和具体编译器实现相关的。比如，Pascal语言中参数就是从左到右入栈的，有些语言中还可以通过修饰符进行指定，如Visual C++。即然两种方式都可以，为什么Ｃ语言要选择从右至左呢？

进一步发现，Pascal语言不支持可变长参数，而Ｃ语言支持这种特色，正是这个原因使得Ｃ语言函数参数入栈顺序为从右至左。具体原因为：C方式参数入栈顺序（从右至左）的好处就是可以动态变化参数个数。通过栈堆分析可知，自左向右的入栈方式，最前面的参数被压在栈底。除非知道参数个数，否则是无法通过栈指针的相对位移求得最左边的参数。这样就变成了左边参数的个数不确定，正好和动态参数个数的方向相反。

因此，Ｃ语言函数参数采用自右向左的入栈顺序，主要原因是为了支持可变长参数形式，C语言中可变参数都是从左到右，所以不管你有多少个参数反正将最右面的那个压入栈底，最左面的参数出入栈顶。换句话说，如果不支持这个特色，Ｃ语言完全和Pascal一样，采用自左向右的参数入栈方式。

Ｃ程序栈底为高地址，栈顶为低地址，

一．函数修饰符：

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

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

1._cdecl 
按 从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于“C”函数或者变量，修饰名是在函数名前 加下划线。对于“C++”函数，有所不同。
如 函数void   test(void)的修饰名是_test； 对于不属于一个类的“C++”全局函数，修饰名是?test@@ZAXXZ。
这 是MFC缺省调用约定。由于是调用者负责把参数弹出栈，所以可以给函数定义个数不定 的参数，如printf函数。
2._stdcall 
按从右至 左的顺序压参数入栈，由被调用者把参数弹出栈。对于“C”函数或者变量，修饰名以下划线为前 缀，然后是函数名，然后是符号“@”及参数的字节数，如函数int   func(int   a,   double   b)的修饰名是_func@12。 对于“C++”函数，则有所不同。
所 有的Win32   API函数都遵循该约定。
3._fastcall 
头两 个DWORD类型或者占更少字节的参数被放入ECX和EDX寄 存器，其他剩下的参数按从右到左的顺序压入栈。由被调用者把参数弹出栈，对于“C”函数或者 变量，修饰名以“@”为前缀，然后是函数名，接着是符号“@”及 参数的字节数，如函数int   func(int   a,   double   b)的 修饰名是@func@12。对于“C++”函 数，有所不同。
未来的编译器可能使用不同的寄存器来存放参数。
4.thiscall 
仅仅应 用于“C++”成员函数。this指 针存放于CX寄存器，参数从右到左压栈。thiscall不 是关键词，因此不能被程序员指定。
5.naked   call 
采用1-4的 调用约定时，如果必要的话，进入函数时编译器会产生代码来保存ESI，EDI，EBX，EBP寄 存器，退出函数时则产生代码恢复这些寄存器的内容。naked   call不产生这样的代 码。
naked   call不 是类型修饰符，故必须和_declspec共同使用，如下：
__declspec(   naked   )   int   func(   formal_parameters   ) 
{ 
//   Function   body 
}

<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

二．函数调用

千万要注意，C不 支持默认参数

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

注释：默认参数：比如说下面的函数

int fun(int a,int b,int c=3)

{

}

c就 是指定的默认实参，通常在函数原型中指定。这里给了3作为默认参数。用平常的时候调用这个函数fun(4,5,6);那 么就是a=4,b=4,c=6。如果这样调用fun(1,2)那 么就是a=1,b=2,c=3，这里c没 有指定，因为c是默认实参，已经有了默认值，这里c就 是采用默认值3。

为什么默认实参必须是函数参数表中 最右边的参数。把上面的函数改下

int fun(int a=3,int b,int c)

{

}

这样调用fun(1,2)， 这样就是a=1,b=2，而c根 本就没有赋到值，就出错了。这些参数都是一一对应的。

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

C/C++支 持可变参数个数的函数定义，这一点与C/C++语言函数参数调用时入栈顺序有 关，
首先引用其他网友的一段文字，来描述函数调用，及参数入栈：
C支持可变参数的函数， 这里的意思是C支持函数带有可变数量的参数，最常见的例子就
是 我们十分熟悉的printf()系列函数。我们还知道在函数调用 时参数是自右向左压栈的。如果可变参数函数的一般形式是：
    f(p1, p2, p3, …)
那么参数进栈（以及出栈）的顺序是：
    …
    push p3
    push p2
    push p1
    call f
    pop p1
    pop p2
    pop p3
    …
我可以得到这样一个结论：如果支持可变参数的函数，那么参数进栈的顺序几乎必然是
自右向左 的。并且，参数出栈也不能由函数自己完成，而应该由调用者完成。

这个结论的后半部分是不难理解的， 因为函数自身不知道调用者传入了多少参数，但是
调用者知道，所以调用者应该负责将所有参数 出栈。

在可变参数函数的一般形式中，左边 是已经确定的参数，右边省略号代表未知参数部分。对于已经确定的参数，它在栈上的位置也必须是确定的。否则意味着已经确定的参数
是 不能定位和找到的，这样是无法保证函数正确执行的。衡量参数在栈上的位置，就是
离开确切的 函数调用点（call f）有多远。已经确定的参数，它在栈上的位置，不应该
依 赖参数的具体数量，因为参数的数量是未知的！

所以，选择只能是，已经确定的参 数，离开函数调用点有确定的距离（较近）。满足这
个条件，只有参数入栈遵从自右向左规则。 也就是说，左边确定的参数后入栈，离函数
调用点有确定的距离（最左边的参数最后入栈，离函 数调用点最近）。

这样，当函数开始执行后，它能找到 所有已经确定的参数。根据函数自己的逻辑，它负
责寻找和解释后面可变的参数（在离开调用点 较远的地方），通常这依赖于已经确定的
参数的值（典型的如prinf()函 数的格式解释，遗憾的是这样的方式具有脆弱性）。

据说在pascal中 参数是自左向右压栈的，与C的相反。对于pascal这 种只支持固定参数函
数的语言，它没有可变参数带来的问题。因此，它选择哪种参数进栈方式都 是可以的。
甚至，其参数出栈是由函数自己完成的，而不是调用者，因为函数的参数的类型和数 量
是完全已知的。这种方式比采用C的 方式的效率更好，因为占用更少的代码量（在C中，
函 数每次调用的地方，都生成了参数出栈代码）。

C++为 了兼容C，所以仍然支持函数带有可变的参数。但是在C++中 更好的选择常常是函数
重载。

函数调用入栈基本步骤（感觉和进程的栈帧结构一块看会比较容易理解）
分类： C/C++ 2011-03-14 22:16 510人阅读 评论(0) 收藏 举报

一、函数调用的基本步骤

函数调用大致包括以下几个步骤。

（1）参数入栈：将参数从右向左依次压入系统栈中。

（2）返回地址入栈：将当前代码区调用指令的下一条指令地址压入栈中，供函数返回时继续执行。

（3）代码区跳转：处理器从当前代码区跳转到被调用函数的入口处。

（4）栈帧调整：具体包括：

保存当前栈帧状态值，已备后面恢复本栈帧时使用（EBP入栈）。

将当前栈帧切换到新栈帧（将ESP值装入EBP，更新栈帧底部）。

给新栈帧分配空间（把ESP减去所需空间的大小，抬高栈顶）。

二、函数调用约定：

 

调用约定的声明
 参数入栈顺序
 恢复栈平衡的位置
 
__cdecl
 右→左
 母函数
 
__fastcall
 右→左
 子函数
 
__stdcall
 右→左
 子函数
 

 

三、具体的表现

（1） __cdecl

       函数本身不清理堆栈，调用者负责清理堆栈。由于这种变化，C调用约定允许函数的参数的个数是不固定的

（2） __fastcall

      函数的第一个和第二个DWORD参数（或者尺寸更小的）通过ecx和edx传递，其他参数通过从右向左的顺序压栈

      被调用函数清理堆栈

（3） __stdcall

     参数从右向左压入堆栈

     函数自身修改堆栈

四、VC下的表现
      在VC的工程设置中可以设置函数调用方式，从表现可以看出明显的差别。
（1）如果设置成__cdecl*，那么对于下面的代码，汇编表现为：
       00402692   push        8
00402694   push        5
00402696   push        3
00402698   call        @ILT+275(GetNum) (00401118)
0040269D   add         esp,0Ch
（2）如果设置成__stdcall，那么对于下面的代码，汇编表现为：
00402692   push        8
00402694   push        5
00402696   push        3
00402698   call        @ILT+280(GetNum) (0040111d)
（3）如果设置成__fastcall，那么对于下面的代码，汇编表现为：
00402692   push        8
00402694   mov         edx,5
00402699   mov         ecx,3
0040269E   call        @ILT+170(GetNum) (004010af)
     
       view plaincopy to clipboardprint?void GetNum( int a, int b, int c )  
{  
    a = 5;  
    b = 0;  
    return;  
}  
 
五、其他调用

（1） thiscall

    thiscall是唯一一个不能明确指明的函数修饰，因为thiscall不是关键字。它是C++类成员函数缺省的调用约定。由于成员函数调用还有一个

    this指针，因此必须特殊处理。

   Microsoft Visual C++提供了thiscall调用约定，它把this保存到ECX寄存器中，并由非静态函数负责从堆栈中清除参数。

   GNU g++编译器把this指针看作是动态成员函数的暗含的第一个参数，并使用cdecall约定中的方法来传递参数。

    表现：

    参数从右向左入栈

    如果参数个数确定，this指针通过ecx传递给被调用者；如果参数个数不确定，this指针在所有参数压栈后被压入堆栈。

    对参数个数不定的，调用者清理堆栈，否则函数自己清理堆栈

对于thiscall，在C++的类中可以定义，那么不管在VC中如何设置函数调用约定，下面的表现都是一定的，即：

func函数有子函数进行清栈，而func1函数有母函数进行清栈。

 

view plaincopy to clipboardprint?class TestCls  
{  
public:  
    TestCls(int a)  
    {  
        m_iData = a;  
    }  
    int func(int a, int b, int c)  
    {  
        int e = m_iData + a + b + c;  
        return e;  
    }  
    CString func1(CString strFMT, ...)  
    {  
        CString strTemp;  
        va_list args;  
        va_start(args, strFMT);  
        strTemp.FormatV(strFMT, args);  
        va_end(args);  
        return strTemp;  
    }  
private:  
    int m_iData;  
};  
 
 

（2） naked call
       这是一个很少见的调用约定，一般程序设计者建议不要使用。编译器不会给这种函数增加初始化和清理代码，更特殊的是：
       你不能用return返回返回值，只能用插入汇编返回结果，这一般用于实模式驱动程序设计。
六、总结
          要想把所有的调用约定都写完，就需要一本单独的书来完成了。调用约定一般指的是语言、编译器和CPU方面的，当你遇到一些很少见的

    编译器编译出的代码时，你就需要好好的研究一下了。在一些情况下需要特别提到：优化的代码，自定义汇编语言代码，和系统调用。

       当一个函数被输出供其它程序员使用时（如库函数），让这些函数遵循人们熟知的调用约定是很重要的，这样可以是程序员很快的掌握函数

    接口。另一方面，如果一个函数仅仅是为了内部程序使用的，那这个函数的调用约定要在程序内部为人所熟知。因此好的编译器会代替某些调用

    约定来产生运行速度更快的代码。例如在使用Microsoft Visual C++的/GL选项或者使用GNU gcc/g++的regparm关键字时，就会出现这种情况。

       当程序员在使用汇编语言时，他又完全的控制权来决定函数的参数如何传递。汇编语言程序员可以用任何他们认为合理的方式来传递参数，

    除非他们想让自己写的函数被其它程序员引用。传统的汇编语言一般在obfuscation routines和shellcode中见到。

       系统调用是用来请求一个系统服务的特殊的函数调用方式。系统调用通常会将操作系统从用户模式切换为内核模式，以使操作系统内核提供

    用户所请求的服务。不同操作系统和不同的CPU的系统调用的方式也是不同的。

分享到： 上一篇：C语言函数入栈顺序与可变参数函数
下一篇：第一场笔试感悟

C/C++堆、栈及静态数据区详解 （转载）
分类： Linux-c C++ 2011-01-16 21:08 273人阅读 评论(0) 收藏 举报
五大内存分区

在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。

堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。

全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）

明确区分堆与栈

在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。

首先，我们举一个例子：

void f() { int* p=new int[5]; }

这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：

00401028 push 14h

0040102A call operator new (00401060)

0040102F add esp,4

00401032 mov dword ptr [ebp-8],eax

00401035 mov eax,dword ptr [ebp-8]

00401038 mov dword ptr [ebp-4],eax

这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。

好了，我们回到我们的主题：堆和栈究竟有什么区别？

主要的区别由以下几点：

1、管理方式不同；

2、空间大小不同；

3、能否产生碎片不同；

4、生长方向不同；

5、分配方式不同；

6、分配效率不同；

管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。

空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：

打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。

注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。

碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。

生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。

分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。

分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。

从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。

虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。

无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的：）

对了，还有一件事，如果有人把堆栈合起来说，那它的意思是栈，可不是堆，呵呵，清楚了？

static用来控制变量的存储方式和可见性

函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？ 最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。

 

需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。