精华内容
下载资源
问答
  • 堆栈的详细讲解

    2020-03-08 14:30:00
    堆栈是一个先进后出的数据结构,栈顶地址总是小于等于栈的基地址。我们可以先了解一下函数调用的过程,以便对堆栈在程序中的作用有更深入的了解。不同的语言有不同的函数调用规定,这些因素有参数的压入规则和堆栈的...

    在讲解堆栈之前,先让我们对堆栈有一个感性的认识

    使用栈:就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。
    使用堆:就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。

    再了解一下堆栈的定义和函数调用的过程中堆栈的样子

    记住堆栈定义中标黄的重点,对理清函数调用过程帮助非常大。

    堆栈的定义:堆栈是一种数据结构,具体是一个特定的存储区或寄存器。堆栈都是一种数据项按序排列的数据结构。只能在一端(称为栈顶(top))对数据项进行插入和删除,也就是它的一端是固定的,另一端(栈顶)是浮动的 ,严格按照“先进后出”的原则存取,位于其中间的元素,必须在其栈上部(后进栈者)诸元素逐个移出后才能取出。因而栈顶地址总是小于等于栈的基地址。

    #include <stdio.h>
    void __stdcall func(int param1,int param2,int param3)
    {
        int var1=param1;
        int var2=param2;
        int var3=param3;
        printf("0x%08x\n",param1); //打印出各个变量的内存地址
        printf("0x%08x\n",param2);
        printf("0x%08x\n\n",param3);
        printf("0x%08x\n",&var1);
        printf("0x%08x\n",&var2);
        printf("0x%08x\n\n",&var3);
        return;
    }
    
    int main() {
        func(1,2,3);
        return 0;
    }
    

    编译后的执行结果是:

    0x0012ff78
    0x0012ff7c
    0x0012ff80
    
    0x0012ff68
    0x0012ff6c
    0x0012ff70
    
    ├———————┤<—函数执行时的栈顶(ESP)、低端内存区域
    │ …… │
    ├———————┤
    │ var 1 │
    ├———————┤
    │ var 2 │
    ├———————┤
    │ var 3 │
    ├———————┤
    │ RET │
    ├———————┤<—“__cdecl”函数返回后的栈顶(ESP)
    │ parameter 1 │
    ├———————┤
    │ parameter 2 │
    ├———————┤
    │ parameter 3 │
    ├———————┤<—“__stdcall”函数返回后的栈顶(ESP)
    │ …… │
    ├———————┤<—栈底(基地址 EBP)、高端内存区域
    

    步骤1:三个参数以从右到左的次序压入堆栈,先压“param3”,再压“param2”,最后压入“param1”;
    步骤2:压入函数的返回地址(RET),接着跳转到函数地址接着执行;
    步骤3:将栈顶(ESP)减去一个数,为本地变量分配内存空间,上例中是减去12字节(ESP=ESP-3*4,每个int变量占用4个字节);接着就初始化本地变量的内存空间。

    最后看看具体堆栈的区别

    两者的定义:

    1. 栈区:存放自动变量。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元由编译器自动释放。栈存放函数的参数值,局部变量的值等。
    2. 堆区(自由存储区):在运行的时候调用程序(如C中的malloc或C++中的new)分配内存,可以在任何时候决定分配内存及分配的大小,用户自己负责在何时释放内存(如用free或delete)。堆中的所有东西都是匿名的,这样不能按名字访问,而只能通过指针访问

    具体的区别:
    申请方式:
    栈区:由系统自动分配。 例如,声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间。
    堆区:需要程序员自己申请,并指明大小,在c中malloc函数
    如p = (char *)malloc(10);但是注意p本身是在栈中的。
    申请后系统的响应:
    栈区:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。
    堆区:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。
    申请大小的限制:
    栈区在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。
    堆区堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。
    申请效率的比较:
    栈区:栈由系统自动分配,速度较快。但程序员是无法控制的。
    堆区:堆由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便。另外,在WINDOWS下,最好的方式是用VirtualAlloc分配内存,他不是在堆,也不是在栈是直接在进程的地址空间中保留一快内存,虽然用起来最不方便。但是速度快,也最灵活。
    堆和栈中的存储内容:
    栈区在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行
    堆区:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。
    存取效率的比较:
    栈区:char *s2 = “bbbbbbbbbbbbbbbbb”;bbbbbbbbbbb是在编译时就确定的;要先把指针值读到edx中,在根据edx读取字符,显然慢了。然而,在栈上的数组比指针所指向的字符串(例如堆)快。
    堆区:char s1[] = “aaaaaaaaaaaaaaa”; aaaaaaaaaaa是在运行时刻赋值的;读取时直接就把字符串中的元素读到寄存器cl中,显然比较快。

    展开全文
  • 关于堆栈的详细讲解

    2018-10-15 18:24:00
    关于堆栈详细讲解 一、预备知识—程序的内存分配 ...其操作方式类似于数据结构中的栈。 2、堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回...

    关于堆栈的详细讲解

    一、预备知识—程序的内存分配

    一个由c/C++编译的程序占用的内存分为以下几个部分 
    1、栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。 
    2、堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵。 
    3、全局区(静态区)(static)—,全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
    4、文字常量区—常量字符串就是放在这里的。 程序结束后由系统释放 
    5、程序代码区—存放函数体的二进制代码。

    二、例子程序

    这是一个前辈写的,非常详细

    //main.cpp
    int a = 0; //全局初始化区
    int a = 0; //全局初始化区
    char *p1; //全局未初始化区
    main() {
        int b; //栈
        char s[] = "abc"; //栈
        char *p2; //栈
        char *p3 = "123456"; //123456\0在常量区,p3在栈上。
        static int c = 0; //全局(静态)初始化区
        p1 = (char *)malloc(10);
        p2 = (char *)malloc(20);
        //分配得来得10和20字节的区域就在堆区。
        strcpy(p1, "123456"); //123456\0放在常量区,编译器可能会将它与p3所指向的"123456"优化成一个地方。
    }

    二、堆和栈的理论知识

    2.1申请方式

    stack: 
    由系统自动分配。 例如,声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间 
    heap: 
    需要程序员自己申请,并指明大小,在c中malloc函数 
    p1 = (char *)malloc(10); 
    在C++中用new运算符 
    p2 = (char *)malloc(10); 
    但是注意p1、p2本身是在栈中的。

    2.2 申请后系统的响应

    栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。 
    堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时, 
    会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。

    2.3 申请大小的限制

    栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。 
    堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。

    2.4 申请效率的比较:

    栈由系统自动分配,速度较快。但程序员是无法控制的。 
    堆是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便. 
    另外,在WINDOWS下,最好的方式是用VirtualAlloc分配内存,他不是在堆,也不是在栈是直接在进程的地址空间中保留一快内存,虽然用起来最不方便。但是速度快,也最灵活。

    2.5 堆和栈中的存储内容

    栈: 在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。 
    当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行。 
    堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

    2.6 存取效率的比较

    char s1[] = "aaaaaaaaaaaaaaa"; 
    char *s2 = "bbbbbbbbbbbbbbbbb"; 
    aaaaaaaaaaa是在运行时刻赋值的; 
    而bbbbbbbbbbb是在编译时就确定的; 
    但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。 
    比如:

    #include
    void main() {
        char a = 1;
        char c[] = "1234567890";
        char *p ="1234567890";
        a = c[1];
        a = p[1];
        return;
    }

    对应的汇编代码

    10: a = c[1];
    00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
    0040106A 88 4D FC mov byte ptr [ebp-4],cl
    11: a = p[1];
    0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
    00401070 8A 42 01 mov al,byte ptr [edx+1]
    00401073 88 45 FC mov byte ptr [ebp-4],al

    第一种在读取时直接就把字符串中的元素读到寄存器cl中,而第二种则要先把指针值读到edx中,在根据edx读取字符,显然慢了。

    2.7小结:

    堆和栈的区别可以用如下的比喻来看出: 
    使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。 
    使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。

    三 、windows进程中的内存结构

    在阅读本文之前,如果你连堆栈是什么多不知道的话,请先阅读文章后面的基础知识。

    接触过编程的人都知道,高级语言都能通过变量名来访问内存中的数据。那么这些变量在内存中是如何存放的呢?程序又是如何使用这些变量的呢?下面就会对此进行深入的讨论。下文中的C语言代码如没有特别声明,默认都使用VC编译的release版。

    首先,来了解一下 C 语言的变量是如何在内存分部的。C 语言有全局变量(Global)、本地变量(Local),静态变量(Static)、寄存器变量(Regeister)。每种变量都有不同的分配方式。先来看下面这段代码:

    #include <stdio.h>
    int g1=0, g2=0, g3=0;
    int main()
    {
        static int s1=0, s2=0, s3=0;
        int v1=0, v2=0, v3=0;
        //打印出各个变量的内存地址    
        printf("0x%08x\n",&v1); //打印各本地变量的内存地址
        printf("0x%08x\n",&v2);
        printf("0x%08x\n\n",&v3);
        printf("0x%08x\n",&g1); //打印各全局变量的内存地址
        printf("0x%08x\n",&g2);
        printf("0x%08x\n\n",&g3);
        printf("0x%08x\n",&s1); //打印各静态变量的内存地址
        printf("0x%08x\n",&s2);
        printf("0x%08x\n\n",&s3);
        return 0;
    }

    编译后的执行结果是:

    0x0012ff78
    0x0012ff7c
    0x0012ff80
    
    0x004068d0
    0x004068d4
    0x004068d8
    
    0x004068dc
    0x004068e0
    0x004068e4

    输出的结果就是变量的内存地址。其中v1,v2,v3是本地变量,g1,g2,g3是全局变量,s1,s2,s3是静态变量。你可以看到这些变量在内存是连续分布的,但是本地变量和全局变量分配的内存地址差了十万八千里,而全局变量和静态变量分配的内存是连续的。这是因为本地变量和全局/静态变量是分配在不同类型的内存区域中的结果。对于一个进程的内存空间而言,可以在逻辑上分成3个部份:代码区,静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈(stack)”和“堆(heap)”是两种不同的动态数据区,栈是一种线性结构,堆是一种链式结构。进程的每个线程都有私有的“栈”,所以每个线程虽然代码一样,但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区,本地变量分配在动态数据区,即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。

    ├———————┤低端内存区域
    │ …… │
    ├———————┤
    │ 动态数据区 │
    ├———————┤
    │ …… │
    ├———————┤
    │ 代码区 │
    ├———————┤
    │ 静态数据区 │
    ├———————┤
    │ …… │
    ├———————┤高端内存区域
    

    堆栈是一个先进后出的数据结构,栈顶地址总是小于等于栈的基地址。我们可以先了解一下函数调用的过程,以便对堆栈在程序中的作用有更深入的了解。不同的语言有不同的函数调用规定,这些因素有参数的压入规则和堆栈的平衡。windows API的调用规则和ANSI C的函数调用规则是不一样的,前者由被调函数调整堆栈,后者由调用者调整堆栈。两者通过“__stdcall”和“__cdecl”前缀区分。先看下面这段代码:

    #include <stdio.h>
    void __stdcall func(int param1,int param2,int param3)
    {
        int var1=param1;
        int var2=param2;
        int var3=param3;
        printf("0x%08x\n",param1); //打印出各个变量的内存地址
        printf("0x%08x\n",param2);
        printf("0x%08x\n\n",param3);
        printf("0x%08x\n",&var1);
        printf("0x%08x\n",&var2);
        printf("0x%08x\n\n",&var3);
        return;
    }
    
    int main() {
        func(1,2,3);
        return 0;
    }

    编译后的执行结果是:

    0x0012ff78
    0x0012ff7c
    0x0012ff80
    
    0x0012ff68
    0x0012ff6c
    0x0012ff70
    ├———————┤<—函数执行时的栈顶(ESP)、低端内存区域
    │ …… │
    ├———————┤
    │ var 1 │
    ├———————┤
    │ var 2 │
    ├———————┤
    │ var 3 │
    ├———————┤
    │ RET │
    ├———————┤<—“__cdecl”函数返回后的栈顶(ESP)
    │ parameter 1 │
    ├———————┤
    │ parameter 2 │
    ├———————┤
    │ parameter 3 │
    ├———————┤<—“__stdcall”函数返回后的栈顶(ESP)
    │ …… │
    ├———————┤<—栈底(基地址 EBP)、高端内存区域
    

    上图就是函数调用过程中堆栈的样子了。首先,三个参数以从右到左的次序压入堆栈,先压“param3”,再压“param2”,最后压入“param1”;然后压入函数的返回地址(RET),接着跳转到函数地址接着执行(这里要补充一点,介绍UNIX下的缓冲溢出原理的文章中都提到在压入RET后,继续压入当前EBP,然后用当前ESP代替EBP。然而,有一篇介绍windows下函数调用的文章中说,在windows下的函数调用也有这一步骤,但根据我的实际调试,并未发现这一步,这还可以从param3和var1之间只有4字节的间隙这点看出来);第三步,将栈顶(ESP)减去一个数,为本地变量分配内存空间,上例中是减去12字节(ESP=ESP-3*4,每个int变量占用4个字节);接着就初始化本地变量的内存空间。由于“__stdcall”调用由被调函数调整堆栈,所以在函数返回前要恢复堆栈,先回收本地变量占用的内存(ESP=ESP+3*4),然后取出返回地址,填入EIP寄存器,回收先前压入参数占用的内存(ESP=ESP+3*4),继续执行调用者的代码。参见下列汇编代码:

    ;--------------func 函数的汇编代码-------------------
    
    :00401000 83EC0C sub esp, 0000000C //创建本地变量的内存空间
    :00401003 8B442410 mov eax, dword ptr [esp+10]
    :00401007 8B4C2414 mov ecx, dword ptr [esp+14]
    :0040100B 8B542418 mov edx, dword ptr [esp+18]
    :0040100F 89442400 mov dword ptr [esp], eax
    :00401013 8D442410 lea eax, dword ptr [esp+10]
    :00401017 894C2404 mov dword ptr [esp+04], ecx
    
    ……………………(省略若干代码)
    
    :00401075 83C43C add esp, 0000003C ;恢复堆栈,回收本地变量的内存空间
    :00401078 C3 ret 000C ;函数返回,恢复参数占用的内存空间
    ;如果是“__cdecl”的话,这里是“ret”,堆栈将由调用者恢复
    
    ;-------------------函数结束-------------------------
    
    ;--------------主程序调用func函数的代码--------------
    
    :00401080 6A03 push 00000003 //压入参数param3
    :00401082 6A02 push 00000002 //压入参数param2
    :00401084 6A01 push 00000001 //压入参数param1
    :00401086 E875FFFFFF call 00401000 //调用func函数
    ;如果是“__cdecl”的话,将在这里恢复堆栈,“add esp, 0000000C”

    聪明的读者看到这里,差不多就明白缓冲溢出的原理了。先来看下面的代码:

    #include <stdio.h>
    #include <string.h>
    
    void __stdcall func() {
        char lpBuff[8]="\0";
        strcat(lpBuff,"AAAAAAAAAAA");
        return;
    }
    
    int main() {
        func();
        return 0;
    }

    编译后执行一下回怎么样?哈,“”0x00414141”指令引用的”0x00000000”内存。该内存不能为”read”。”,“非法操作”喽!”41”就是”A”的16进制的ASCII码了,那明显就是strcat这句出的问题了。”lpBuff”的大小只有8字节,算进结尾的\0,那strcat最多只能写入7个”A”,但程序实际写入了11个”A”外加1个\0。再来看看上面那幅图,多出来的4个字节正好覆盖了RET的所在的内存空间,导致函数返回到一个错误的内存地址,执行了错误的指令。如果能精心构造这个字符串,使它分成三部分,前一部份仅仅是填充的无意义数据以达到溢出的目的,接着是一个覆盖RET的数据,紧接着是一段shellcode,那只要这个RET地址能指向这段shellcode的第一个指令,那函数返回时就能执行shellcode了。但是软件的不同版本和不同的运行环境都可能影响这段shellcode在内存中的位置,那么要构造这个RET是十分困难的。一般都在RET和shellcode之间填充大量的NOP指令,使得exploit有更强的通用性。

    ├———————┤<—低端内存区域
    │ …… │
    ├———————┤<—由exploit填入数据的开始
    │ │
    │ buffer │<—填入无用的数据
    │ │
    ├———————┤
    │ RET │<—指向shellcode,或NOP指令的范围
    ├———————┤
    │ NOP │
    │ …… │<—填入的NOP指令,是RET可指向的范围
    │ NOP │
    ├———————┤
    │ │
    │ shellcode │
    │ │
    ├———————┤<—由exploit填入数据的结束
    │ …… │
    ├———————┤<—高端内存区域

    windows下的动态数据除了可存放在栈中,还可以存放在堆中。了解C++的朋友都知道,C++可以使用new关键字来动态分配内存。来看下面的C++代码:

    #include <stdio.h>
    #include <iostream.h>
    #include <windows.h>
    
    void func()
    {
        char *buffer=new char[128];
        char bufflocal[128];
        static char buffstatic[128];
        printf("0x%08x\n",buffer); //打印堆中变量的内存地址
        printf("0x%08x\n",bufflocal); //打印本地变量的内存地址
        printf("0x%08x\n",buffstatic); //打印静态变量的内存地址
    }
    
    void main() {
        func();
        return;
    }

    程序执行结果为:

    0x004107d0
    0x0012ff04
    0x004068c0

    可以发现用new关键字分配的内存即不在栈中,也不在静态数据区。VC编译器是通过windows下的“堆(heap)”来实现new关键字的内存动态分配。在讲“堆”之前,先来了解一下和“堆”有关的几个API函数:

    - HeapAlloc 在堆中申请内存空间
    - HeapCreate 创建一个新的堆对象
    - HeapDestroy 销毁一个堆对象
    - HeapFree 释放申请的内存
    - HeapWalk 枚举堆对象的所有内存块
    - GetProcessHeap 取得进程的默认堆对象
    - GetProcessHeaps 取得进程所有的堆对象
    - LocalAlloc
    - GlobalAlloc

    当进程初始化时,系统会自动为进程创建一个默认堆,这个堆默认所占内存的大小为1M。堆对象由系统进行管理,它在内存中以链式结构存在。通过下面的代码可以通过堆动态申请内存空间:

    HANDLE hHeap=GetProcessHeap();
    char *buff=HeapAlloc(hHeap,0,8);

    其中hHeap是堆对象的句柄,buff是指向申请的内存空间的地址。那这个hHeap究竟是什么呢?它的值有什么意义吗?看看下面这段代码吧:

    #pragma comment(linker,"/entry:main") //定义程序的入口
    #include <windows.h>
    
    _CRTIMP int (__cdecl *printf)(const char *, ...); //定义STL函数printf
    /*---------------------------------------------------------------------------
     写到这里,我们顺便来复习一下前面所讲的知识:
     (*注)printf函数是C语言的标准函数库中函数,VC的标准函数库由msvcrt.dll模块实现。
     由函数定义可见,printf的参数个数是可变的,函数内部无法预先知道调用者压入的参数个数,函数只能通过分析第一个参数字符串的格式来获得压入参数的信息,由于这里参数的个数是动态的,所以必须由调用者来平衡堆栈,这里便使用了__cdecl调用规则。BTW,Windows系统的API函数基本上是__stdcall调用形式,只有一个API例外,那就是wsprintf,它使用__cdecl调用规则,同printf函数一样,这是由于它的参数个数是可变的缘故。
     ---------------------------------------------------------------------------*/
    void main()
    {
        HANDLE hHeap=GetProcessHeap();
        char *buff=HeapAlloc(hHeap,0,0x10);
        char *buff2=HeapAlloc(hHeap,0,0x10);
        HMODULE hMsvcrt=LoadLibrary("msvcrt.dll");
        printf=(void *)GetProcAddress(hMsvcrt,"printf");
        printf("0x%08x\n",hHeap);
        printf("0x%08x\n",buff);
        printf("0x%08x\n\n",buff2);
    }

    执行结果为:

    0x00130000
    0x00133100
    0x00133118

    hHeap的值怎么和那个buff的值那么接近呢?其实hHeap这个句柄就是指向HEAP首部的地址。在进程的用户区存着一个叫PEB(进程环境块)的结构,这个结构中存放着一些有关进程的重要信息,其中在PEB首地址偏移0x18处存放的ProcessHeap就是进程默认堆的地址,而偏移0x90处存放了指向进程所有堆的地址列表的指针。windows有很多API都使用进程的默认堆来存放动态数据,如windows 2000下的所有ANSI版本的函数都是在默认堆中申请内存来转换ANSI字符串到Unicode字符串的。对一个堆的访问是顺序进行的,同一时刻只能有一个线程访问堆中的数据,当多个线程同时有访问要求时,只能排队等待,这样便造成程序执行效率下降。

    最后来说说内存中的数据对齐所位数据对齐,是指数据所在的内存地址必须是该数据长度的整数倍,DWORD数据的内存起始地址能被4除尽,WORD数据的内存起始地址能被2除尽,x86 CPU能直接访问对齐的数据,当他试图访问一个未对齐的数据时,会在内部进行一系列的调整,这些调整对于程序来说是透明的,但是会降低运行速度,所以编译器在编译程序时会尽量保证数据对齐。同样一段代码,我们来看看用VC、Dev-C++和lcc三个不同编译器编译出来的程序的执行结果:

    #include <stdio.h>
    
    int main()
        {
        int a;
        char b;
        int c;
        printf("0x%08x\n",&a);
        printf("0x%08x\n",&b);
        printf("0x%08x\n",&c);
        return 0;
    }

    这是用VC编译后的执行结果:

    0x0012ff7c
    0x0012ff7b
    0x0012ff80

    变量在内存中的顺序:b(1字节)-a(4字节)-c(4字节)。

    这是用Dev-C++编译后的执行结果:

    0x0022ff7c
    0x0022ff7b
    0x0022ff74

    变量在内存中的顺序:c(4字节)-中间相隔3字节-b(占1字节)-a(4字节)。

    这是用lcc编译后的执行结果:

    0x0012ff6c
    0x0012ff6b
    0x0012ff64

    变量在内存中的顺序:同上。

    三个编译器都做到了数据对齐,但是后两个编译器显然没VC“聪明”,让一个char占了4字节,浪费内存哦。

    基础知识:
    堆栈是一种简单的数据结构,是一种只允许在其一端进行插入或删除的线性表。允许插入或删除操作的一端称为栈顶,另一端称为栈底,对堆栈的插入和删除操作被称为入栈和出栈。有一组CPU指令可以实现对进程的内存实现堆栈访问。其中,POP指令实现出栈操作,PUSH指令实现入栈操作。CPU的ESP寄存器存放当前线程的栈顶指针,EBP寄存器中保存当前线程的栈底指针。CPU的EIP寄存器存放下一个CPU指令存放的内存地址,当CPU执行完当前的指令后,从EIP寄存器中读取下一条指令的内存地址,然后继续执行。

    --------------------- 
    作者:yingms
    来源:CSDN 
    原文:https://blog.csdn.net/yingms/article/details/53188974

    posted @ 2018-10-15 18:24 林深时见鹿! 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • 最近在跑程序时出现核心已转储的问题,后来经过某宝技术人员的讲解发现是内存不够,为此,专门找了下malloc分配内存的相关知识,找到了一个...操作方式类似于数据结构中的栈。 2、堆区(heap)—一般由程序员分配...

    最近在跑程序时出现核心已转储的问题,后来经过某宝技术人员的讲解发现是内存不够,为此,专门找了下malloc分配内存的相关知识,找到了一个比较详细的关于堆栈的讲解,现放到此处记录分享:

    如有侵权,立即删除!https://bbs.csdn.net/topics/90407725

    堆和栈的区别

    一个由C/C++编译的程序占用的内存分为以下几个部分
    1、栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其
    操作方式类似于数据结构中的栈。
    2、堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回
    收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵。
    3、全局区(静态区)(static)—,全局变量和静态变量的存储是放在一块的,初始化的
    全局变量和静态变量在一块区域, 未初始化的全局变量和未初始化的静态变量在相邻的另
    一块区域。 - 程序结束后由系统释放。
    4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放
    5、程序代码区—存放函数体的二进制代码。

    二、例子程序 
    这是一个前辈写的,非常详细 
    //main.cpp 
    int a = 0; 全局初始化区 
    char *p1; 全局未初始化区 
    main() 

    int b; 栈 
    char s[] = "abc"; 栈 
    char *p2; 栈 
    char *p3 = "123456"; 123456\0在常量区,p3在栈上。 
    static int c =0; 全局(静态)初始化区 
    p1 = (char *)malloc(10); 
    p2 = (char *)malloc(20); 
    分配得来得10和20字节的区域就在堆区。 
    strcpy(p1, "123456"); 123456\0放在常量区,编译器可能会将它与p3所指向的"123456"
    优化成一个地方。 
    }

    展开全文
  • 主要内容包括:面向对象编程基本原理,判定算法效率方法,堆栈、队列及其应用,对于多种递归的详细讨论,二叉树、B树、2-4树等查找和遍历等,分析排序、散列等数据结构的应用,图、NP完整性,数据压缩算法、...
  • 第86例ccAm2910四位微程序控制器的堆栈 第87例 Am2910四位微程序控制器的指令译码器 第88例 可控制计数器 第89例 四位超前进位加法器 第90例 实现窗口搜索算法的并行系统(1)——协同处理器 第91例 实现窗口搜索...
  • 结构

    2017-06-20 12:30:00
    结构属于值类型,也就是存储在堆栈中详细讲解请看2.3.3值类型和引用类型),通过这种方式可以在数据的生存期上获得很大灵活性,但性能会有一定损失。因为托管堆优化,这种性能损失比较小。 结构和类一样...

    结构属于值类型,也就是存储在堆栈中(详细讲解请看2.3.3值类型和引用类型),通过这种方式可以在数据的生存期上获得很大的灵活性,但性能会有一定的损失。因为托管堆的优化,这种性能损失比较小。

    结构和类一样可以拥有成员,包括:构造函数、方法、属性、字段、常量、枚举类型、事件、以及事件处理函数等。

    有时我们需要一个小的数据结构,此时,类提供的功能多于我们需要的功能,由于性能的原因,我们最好使用结构。

    例如,我们需要一个结构来记录点的坐标,我们可以定义下面的结构,而不需要定义一个类:

     1         struct Point
     2         {
     3             // 点的横坐标
     4             public double X { get; set; }
     5             // 点的纵坐标
     6             public double Y { get; set; }
     7             // 点的坐标信息
     8             public string PointInfo
     9             {
    10                 get
    11                 {
    12                     return "(" + this.X + ":" + this.Y + ")";
    13                 }
    14             }
    15         }

    结构使用关键字struct进行定义,结构具有以下特点:

    • 属于值类型,派生自System.ValueType
    • 结构不支持继承(所以结构中成员的访问修饰符不能是protected)
    • 结构可以实现接口
    • 对于结构,构造函数的工作方式与引用类型的构造函数有一些区别,结构提供了一个没有参数的默认构造函数,这个默认的构造函数不允许替换
    • 在结构中定义字段时,不可以对其进行初始化,必须通过构造函数对字段进行初始化

    1.结构不支持继承

    结构不是为继承设计的。这以为着:它不能从一个结构中继承。但是,结构最终派生于System.Object类。结构是一个值类型,所有值类型都派生自System.ValueType类,而System.ValueType类又派生自System.Object类。所以我们可以调用甚至重写System.Object中的一些方法。

    2.结构默认的无参构造函数不允许替换

    也就是不允许用户在结构内部显式定义无参的构造函数。如果我们结构定义了无参的构造函数就会报错:

     1         struct Point
     2         {
     3             //为结构显示定义一个无参的构造函数----这是错误的做法
     4             public Point()
     5             {
     6 
     7             }
     8             // 点的横坐标
     9             public double X { get; set; }
    10             // 点的纵坐标
    11             public double Y { get; set; }
    12             // 点的坐标信息
    13             public string PointInfo
    14             {
    15                 get
    16                 {
    17                     return "(" + this.X + ":" + this.Y + ")";
    18                 }
    19             }
    20         }

    错误:

    3.在结构中定义字段时,不可以对其进行初始化,必须通过构造函数对字段进行初始化

    2.1 变量的声明及初始化中讲到,默认构造函数会将值类型的字段初始化为对应类型的默认值,把引用类型的字段初始化为Null,即使提供了其他带参数的构造函数,也是如此。为字段提供初始值也会被构造函数改变,所以如果为结构中的字段设置初始值就会报错:

     1         struct Point
     2         {
     3             // 点的横坐标
     4             public double X = 200;
     5             // 点的纵坐标
     6             public double Y = 300;
     7             // 点的坐标信息
     8             public string PointInfo
     9             {
    10                 get
    11                 {
    12                     return "(" + this.X + ":" + this.Y + ")";
    13                 }
    14             }
    15         }

    错误:

     

    虽然结构是值类型,但是在语法上有与引用类型非常相似,例如在定义时:

    1             Point point = new Point();
    2             point.X = 200;
    3             point.Y = 800;

    但是我们应该注意的是,结构是一个值类型,所以关键字new和其他应用类型的工作方式不同;结构中的关键字new不在托管堆中分配内存空间,而是直接调用相应的构造函数,根据传递的参数对字段进行初始化,然后将其压入堆栈中。

    结构和类的区别:

    • 结构是值类型,类是引用类型;这就导致结构存储在堆栈中,而类存储在托管堆中;
    • 结构不能继承或被继承,类可以继承或被继承;这就导致结构中的成员不能使用proteccted修饰;
    • 结构中不能在定义字段是为其赋初始值,类可以
    • 结构不可以显示定义无参的默认构造函数,类可以

    转载于:https://www.cnblogs.com/cs569/p/7050943.html

    展开全文
  • jQuery详细教程

    2013-04-25 14:16:42
    jQuery详细教程,讲解很透彻, 一. jQuery 语法实例 $(this).hide() 演示 jQuery hide() 函数,隐藏当前 HTML 元素。 $("#test").hide() 演示 jQuery hide() 函数,隐藏 id="test" 元素。 $("p").hide() ...
  • 通过学习书中的代码和图例,您不仅能访问和修改数据库信息,编写功能强大的pl/sql语句,执行有效的查询和部署稳固的安全性,还能轻松实现c、c++和java过程,建立可启用web的数据库,缩短开发时间和优化性能。...
  • 第2~8章对预处理、选择结构和循环结构的程序设计、数组、指针、数据结构、函数和文件等知识点的核心问题和注意事项进行了讲解;第9章介绍了调试和异常处理的方法及注意事项;第10章对C语言中的若干容易让开发者误解...
  • 本书主要目的是向使用高级语言程序员讲解编译器如何从C和C++程序创建汇编语言例程,以及编程人员应如何掌握生成汇编语言代码,调整汇编语言例程以提高应用程序性能。 本书适合有一定编程经验开发人员参考...
  • 还介绍了排序算法及数据结构的实现,包括链表、堆栈、队列和树。此外,本书开始用两章篇幅详细介绍了英文面试注意事项、常见问题及程序员职业规划等软件工程师常识。最后四章详细讲解了现在流行智力测试题...
  •  从Windows最基本两类驱动程序编译、安装、调试入手讲解,非常容易上手,用实例详细讲解PCI、USB、虚拟串口、虚拟摄像头、SDIO等驱动程序开发,归纳了多种调试驱动程序高级技巧,如用WinDBG和VMWARE软件对...
  • ·详细讲述了数制系统和数据存储基础知识 ·所有例子程序都在MicrosoftMASM 6.15编译器下测试通过 ·讲述了高级语言内嵌汇编代码以及汇编语言程序同实地址模式及保护模式C/C++程序链接 ·附带扩展...
  • ·详细讲述了数制系统和数据存储基础知识 ·所有例子程序都在MicrosoftMASM 6.15编译器下测试通过 ·讲述了高级语言内嵌汇编代码以及汇编语言程序同实地址模式及保护模式C/C++程序链接 ·附带扩展...
  • 《iOS开发指南》(第二版 iOS7)源码

    千次下载 热门讨论 2014-03-20 11:11:59
     第18章首先介绍了一些常用调试工具、异常堆栈报告分析,接下来讲解了如何在真机上调试应用,最后分析了Xcode设备管理工具用法。  第19章讨论了测试驱动iOS开发,介绍了测试驱动开发流程。此外,还介绍了...
  • 通过学习书中的代码和图例,您不仅能访问和修改数据库信息,编写功能强大的pl/sql语句,执行有效的查询和部署稳固的安全性,还能轻松实现c、c++和java过程,建立可启用web的数据库,缩短开发时间和优化性能。...
  • The Art of Assembly Language

    2009-07-30 19:06:48
    2.4 数据结构 2.5 二进制数与十六进制数算术运算 2.6 关于数字及其表示法 2.7 位逻辑运算 2.8 二进制数和位串逻辑运算 2.9 有符号数和无符号数 2.10 符号扩展、零扩展、压缩和饱和 2.11 侈位和缩环移位 2.12 ...
  • 第二部分是提高部分,以80386为背景,以新一代微处理器Pentium为目标,细致和通俗地介绍了保护方式下有关概念,系统和详细讲解了保护方式下编程技术,真实和生动地展示了保护方式下编程细节。第三部分是上机...
  • 本教程共分为5个部分,第一部分是C语言提高部分,第二部分为C++基础部分,第三部分为C++进阶部分,第四部分为C、C++及数据结构基础部分,第五部分为C_C++与设计模式基础,内容非常详细. 第一部分 C语言提高部分目录...
  • 如何判断应用是不是需要一个导航功能,并且知道在什么情况下选择平铺导航、标签导航、树形结构导航中的哪一种或者同时综合使用3种导航模式。 第7章“iPhone与iPad应用开发的差异”。掌握 iPhone和iPad设备使用场景上...
  • 尹成Python27天入门到项目实战

    千人学习 2020-12-05 17:04:22
    堆栈函数模块引用系统模块引用与错误列表生成式若干方法生成矩阵str与reprpython把输入输出设备当作文件处理写入中文写入英文读取中文读取英文读取错误写入错误处理文件缓存区文件读取若干种方式for循环按行读取...
  • 详细介绍了opengl es各方面的基础知识,第二篇则对7个真实案例的开发步骤进行了详细的介绍,逐步向读者讲解android 3d游戏的真实开发过程,同时源代码中还包含了详细的注释,以尽量帮助读者掌握代码中的每一个细节,...
  • iOS6开发指南源码

    2013-06-09 15:20:30
    如何判断应用是不是需要一个导航功能,并且知道在什么情况下选择平铺导航、标签导航、树形结构导航中的哪一种或者同时综合使用3种导航模式。 第7章“iPhone与iPad应用开发的差异”。掌握 iPhone和iPad设备使用场景上...
  •  从Windows最基本两类驱动程序编译、安装、调试入手讲解,非常容易上手,用实例详细讲解 PCI、USB、虚拟串口、虚拟摄像头、SDIO等驱动程序开发,归纳了多种调试驱动程序高级技巧,如 用WinDBG和VMWARE...

空空如也

空空如也

1 2 3
收藏数 55
精华内容 22
关键字:

数据结构中的堆栈详细讲解

数据结构 订阅