精华内容
下载资源
问答
  • C++内存分配方式详解

    2015-03-15 20:25:25
    其中编程内存包括:应用代码和应用数据区。 一个由C/C++编译的程序占用的内存分为以下几个部分  栈,就是那些由编译器在需要的时候分配,在不需要的时候自动清除的变量的存储区。里面的变量通常...

    整个系统的内存分为:系统代码、系统数据区,应用代码、应用数据区。

    其中可编程内存包括:应用代码和应用数据区。


    一个由C/C++编译的程序占用的内存分为以下几个部分 


    ,就是那些由编译器在需要的时候分配,在不需要的时候自动清除的变量的存储区。里面的变量通常是局部变量、函数参数等。在一个进程中,位于用户虚拟地址空间顶部的是用户栈,编译器用它来实现函数的调用。和堆一样,用户栈在程序执行期间可以动态地扩展和收缩。

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

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

    全局/静态存储区,全局变量和静态变量被分配到同一块内存中,在以前的 C 语言中,全局变量又分为初始化的和未初始化的(初始化的全局变量和静态变量在一块区域,未初始化的全局变量与静态变量在相邻的另一块区域,同时未被初始化的对象存储区可以通过 void* 来访问和操纵,程序结束后由系统自行释放),在 C++ 里面没有这个区分了,他们共同占用同一块内存区。

    常量存储区,常量字符串就是放在这里的,这是一块比较特殊的存储区,他们里面存放的是常量,不允许修改(当然,你要通过非正当手段也可以修改,而且方法很多)

    程序代码区:存放函数体的二进制代码

     函数指针指向Code区,是程序运行的指令代码,数据指针指向Data,Heap,Stack区,是程序依赖以运行的各种数据

    栈和堆的区别和联系

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

    int b; 栈 
    char s[] = "abc"; 栈 
    char *p2; 栈 
    char *p3 = "123456"; 123456在常量区,p3在栈上。 
    static int c =0; 全局(静态)初始化区 
    p1 = (char *)malloc(10); 
    p2 = (char *)malloc(20); 
    分配得来得10和20字节的区域就在堆区。 
    strcpy(p1, "123456"); 123456放在常量区,编译器可能会将它与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小结: 
    堆和栈的区别可以用如下的比喻来看出: 
    使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。 
    使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。

    1、内存分配方面:

        堆:一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事,分配方式是类似于链表。可能用到的关键字如下:new、malloc、delete、free等等。

        栈:由编译器(Compiler)自动分配释放,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。

    2、申请方式方面:

        堆:需要程序员自己申请,并指明大小。在c中malloc函数如p1 = (char *)malloc(10);在C++中用new运算符,但是注意p1、p2本身是在栈中的。因为他们还是可以认为是局部变量。

        栈:由系统自动分配。 例如,声明在函数中一个局部变量 int b;系统自动在栈中为b开辟空间。

    3、系统响应方面:

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

        栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。

    4、大小限制方面:

        堆:是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。

        栈:在Windows下, 栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是固定的(是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。

    5、效率方面:

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

        栈:由系统自动分配,速度较快。但程序员是无法控制的。

    6、存放内容方面:

        堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

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

    7、存取效率方面:

        堆:char *s1 = "Hellow Word";是在编译时就确定的;

        栈:char s1[] = "Hellow Word"; 是在运行时赋值的;用数组比用指针速度要快一些,因为指针在底层汇编中需要用edx寄存器中转一下,而数组在栈上直接读取。



    展开全文
  • 连续分配管理方式:连续分配方式,是指为一个用户程序分配一个连续的内存空间,主要包括单一连续分配、固定分区分配和动态分区分配。 1、 单一连续分配 内存在此方式下分为系统区和用户区,系统区仅提供给操作系统用...

    连续分配管理方式:连续分配方式,是指为一个用户程序分配一个连续的内存空间,主要包括单一连续分配、固定分区分配和动态分区分配。
    1、 单一连续分配
    内存在此方式下分为系统区和用户区,系统区仅提供给操作系统用,通常在低地址部分;用户区是为用户提供的、除系统区之外的内存空间。这种方式无需进行内存保护。因为内存中永远只有一道程序。这种方式优点是简单、无外部碎片,可采用覆盖技术,不需要额外技术支持。缺点是只能用于单用户、单任务的操作系统中,有内部碎片,存储器的利用率极低。
    2、 固定分区分配:一种多道程序存储管理方式,将用户内存空间划分为若干个固定大小的区域,每个分区只装一道作业。当有空闲分区时,便可以再从外存的后备作业队列中,选择适当大小的作业装入该分区,如此循环。
    在这里插入图片描述

    2.1分区大小相等:用于利用一台计算机去控制多个相同对象的场合,缺乏灵活性
    2.2分区大小不相等:划分为含有多个较小的分区、适量的中等分区和少量的大分区

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 按照内存空间划分方式的不同将连续分配方式划分为以下四种方式: 1. 单一连续分配 2. 固定分区分配 3. 动态分区分配 4. 重定位分区分配1.1.单一连续分配概念:将内存空间分为系统区和用户区。系统区放在...

    操作系统-内存管理-内存空间的连续分配方式


    1.概述、分类

    内存空间的连续分配方式,是指为一个用户程序(作业)分配一个连续的内存空间。
    按照内存空间划分方式的不同可将连续分配方式划分为以下四种方式:

    1. 单一连续分配
    2. 固定分区分配
    3. 动态分区分配
    4. 可重定位分区分配

    1.1.单一连续分配

    概念:将内存空间分为系统区用户区。系统区放在内存低地址部分,且仅供OS使用。用户区是除系统区外的其他地内存空间,用户区给用户使用。

    缺陷:只适用于单用户、单任务环境。

    1.2.固定分区分配

    概念:将内存空间分为若干个固定大小的分区,每个分区中只装入一道作业,允许有几道作业并发运行。

    与磁盘分区相区别:固定分区分配中的分区指的是对内存空间的分配,而磁盘分区指的是对磁盘空间的分配。

    分区划分方法

    1. 分区大小相等:将内存空间划分为若干个大小相等的分区。这种划分方式的缺点是缺乏灵活性,当程序太小时,空间浪费;程序太大,程序无法加载进内存
    2. 分区大小不等:将内存空间划分为多个小分区、适量中等分区、少量大分区。解决了分区大小相等时的不灵活,可依据程序大小分配合适大小的分区

    缺陷:由于每个分区的大小固定,所以会造成内存空间的浪费

    1.3.动态分区分配

    概念:按照进程的实际需要,动态的为该进程分配一段连续的内存空间。与固定分区的本质区别是该分区的大小不是固定不变的,但是需要注意的是,在进程的生命周期中,属于该进程的分区大小是不变的。

    为了描述分区的使用情况,有两种数据结构可供选择

    1. 空闲分区表:用于记录空闲分区的情况。每一个分区占用一个表项,表项中包含空闲分区的序号、分区起始地址、分区大小等。空闲分区表与分区使用表相似,本质区别是,一个分区使用表的表项对应的是一个固定分区,无论该固定分区是否被作业占用;而一个空闲分区表对应的是一个未被进程占用的空闲分区。
    2. 空闲分区链:一个空闲分区对应一个双向链表节点,每个链表节点包含指向前一个空闲分区和指针和指向后一个空闲分区的指针,还包含分区大小和状态位(是否已分配)。

    分区分配算法(以空闲分区链来说明情况):

    1. 首次适应算法:
      空闲分区链以地址递增方式次序链接;从链表首部开始查找大小满足要求的空闲分区(首次适应的含义);将找到的空闲分区中的一块内存空间分配给对应作业。优点是保留了高地址部分的内存空间给以后到达的大作业。缺点是地址部分不断被划分会留下很多难以被重新利用的零头(碎片),而且每次查找链表都是从低地址部分查找,然而低地址部分已经被占用,这样就增加了查找空闲分区的时间。

    2. 循环首次适应算法:
      与首次适应算法类似,本质区别是,循环首次适应算法的链表是一个双向循环链表,所以每次查找空闲分区不是从链表的首部开始查,而是从上一个找到的空闲分区的下一个空闲分区开始查找(起始查询指针指向该链表节点)。优点是能够使内存中的空闲分区分布地更均匀,从而可以减少查找空闲分区的时间。缺点是这样做会使内存空间中缺少大的空闲分区

    3. 最佳适应算法:
      为了加速在链表中查找空闲分区的时间,将空闲分区按照内存容量大小排序,在内存分配时,总能找到容量大小最佳的空闲分区。优点是可以最大程度的减少查找空闲分区的时间。缺点是会留下许多难以被重新利用的零头(碎片)

    内存的分配与回收

    Created with Raphaël 2.1.0开始查找空闲分区表/链还有表项/节点没查找?m.size>u.size?m.size-u.size<=size?将该分区从链表中移除将该移除的分区全部分配给作业修改相应的数据结构(链表表项、链表重排序、起始查询指针)结束从该分区中划分出u.size大小的分区并分配给作业回收该分区剩余内存,可能会进行分区合并yesnoyesnoyesno

    备注:

    1. u.size:作业运行需要的的分区大小
    2. m.size:空闲分区的大小
    3. size:事先规定的不再切割的剩余分区的大小

    1.4.可重定位分区分配

    概念:在动态分区分配中有很多分散的不能被利用的小分区(零头、碎片)。通过移动内存中作业的位置可以将这些分散的小分区拼接成一个大分区,这种技术成为拼接(紧凑)。但是每次拼接(紧凑)后都需要对程序和程序需要的数据进行重定位

    与动态分区分配本质的区别:可重定位分区分配利用拼接(紧凑)将原来分散的小分区拼接成了大分区,这其中涉及到程序移动重定位

    动态重定位的实现:
    采取动态运行时装入的装入方式,实现装入模块(可执行文件)在装入内存后仍然是相对地址,只有在程序指令真正要执行时才将相对地址转换为物理地址。之所以叫做动态重定位,是因为地址变换的过程是随着程序中的每条指令和数据的访问自动进行的。地址转换过程由硬件地址变换机构完成,真正的物理地址=相对地址+重定位寄存器里存放的程序的起始地址。当程序和数据移动后,不需要对程序做任何修改,只需要将程序新的起始地址放入重定位寄存器即可。

    动态重定位分区分配算法
    与动态分区分配算法的主要区别在于动态重定位分区分配算法中增加了拼接(紧凑)功能。

    Created with Raphaël 2.1.0开始查找空闲分区表/链还有表项/节点没查找?m.size>u.size?m.size-u.size<=size?将该分区从链表中移除将该移除的分区全部分配给作业修改相应的数据结构(链表表项、链表重排序、起始查询指针)结束从该分区中划分出u.size大小的分区并分配给作业回收该分区剩余内存,可能会进行分区合并空闲分区总和>=u.size?进行分区的拼接(紧凑),形成连续的空闲分区,修改相关的数据结构yesnoyesnoyesnoyesno
    展开全文
  • 内存分配

    2014-01-24 13:37:49
    学习c++如果不了解内存分配是一件非常可悲的事情。而且,可以这样讲,一个C++程序员无法掌握内存、无法了解内存,是不能够成为一个合格的C++程序员的。  一、内存基本构成  编程内存在基本上分为...

    学习c++如果不了解内存分配是一件非常可悲的事情。而且,可以这样讲,一个C++程序员无法掌握内存、无法了解内存,是不能够成为一个合格的C++程序员的。

      一、内存基本构成

      可编程内存在基本上分为这样的几大部分:静态存储区、堆区和栈区。他们的功能不同,对他们使用方式也就不同。

      静态存储区:内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。它主要存放静态数据、全局数据和常量。

      栈区:在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。

      堆区:亦称动态内存分配。程序在运行的时候用mallocnew申请任意大小的内存,程序员自己负责在适当的时候用freedelete释放内存。动态内存的生存期可以由我们决定,如果我们不释放内存,程序将在最后才释放掉动态内存。但是,良好的编程习惯是:如果某动态内存不再使用,需要将其释放掉,否则,我们认为发生了内存泄漏现象。

      二、三者之间的区别

      我们通过代码段来看看对这样的三部分内存需要怎样的操作和不同,以及应该注意怎样的地方。

      例一:静态存储区与栈区

      char* p= “Hello World1”

      char a[]= “Hello World2”

      p[2]=‘A’

      a[2]=‘A’

      char* p1= “Hello World1

      这个程序是有错误的,错误发生在p[2]=‘A’这行代码处,为什么呢,是变量p和变量数组a都存在于栈区的(任何临时变量都是处于栈区的,包括在main()函数中定义的变量)。但是,数据HelloWorld1”和数据HelloWorld2”是存储于不同的区域的。

      因为数据HelloWorld2”存在于数组中,所以,此数据存储于栈区,对它修改是没有任何问题的。因为指针变量p仅仅能够存储某个存储空间的地址,数据HelloWorld1”为字符串常量,所以存储在静态存储区。虽然通过p[2]可以访问到静态存储区中的第三个数据单元,即字符l’所在的存储的单元。但是因为数据HelloWorld1”为字符串常量,不可以改变,所以在程序运行时,会报告内存错误。并且,如果此时对pp1输出的时候会发现pp1里面保存的地址是完全相同的。换句话说,在数据区只保留一份相同的数据。来源:考试大-计算机二级考试

    例二:栈区与堆区

      char*f1()

      {

      char* p= NULL

      char a

      p =

      returnp

      }

      char*f2()

      {

      char* p= NULL

      p=char*newchar[4]

      returnp

      }

      这两个函数都是将某个存储空间的地址返回,二者有何区别呢?f1()函数虽然返回的是一个存储空间,但是此空间为临时空间。也就是说,此空间只有短暂的生命周期,它的生命周期在函数f1()调用结束时,也就失去了它的生命价值,即:此空间被释放掉。所以,当调用f1()函数时,如果程序中有下面的语句:

      char* p

      p =f1();

      *p =‘a’

      此时,编译并不会报告错误,但是在程序运行时,会发生异常错误。因为,你对不应该操作的内存(即,已经释放掉的存储空间)进行了操作。但是,相比之下,f2()函数不会有任何问题。因为,new这个命令是在堆中申请存储空间,一旦申请成功,除非你将其delete或者程序终结,这块内存将一直存在。也可以这样理解,堆内存是共享单元,能够被多个函数共同访问。如果你需要有多个数据返回却苦无办法,堆内存将是一个很好的选择。但是一定要避免下面的事情发生:

      void f()

      {

      

      char *p

      p=char*newchar[100]

      

      }

      这个程序做了一件很无意义并且会带来很大危害的事情。因为,虽然申请了堆内存,p保存了堆内存的首地址。但是,此变量是临时变量,当函数调用结束时p变量消失。也就是说,再也没有变量存储这块堆内存的首地址,我们将永远无法再使用那块堆内存了。但是,这块堆内存却一直标识被你所使用(因为没有到程序结束,你也没有将其delete,所以这块堆内存一直被标识拥有者是当前您的程序),进而其他进程或程序无法使用。我们将这种不道德的流氓行为(我们不用,却也不让别人使用)称为内存泄漏。这是我们C++程序员的大忌!!请大家一定要避免这件事情的发生。

      总之,对于堆区、栈区和静态存储区它们之间最大的不同在于,栈的生命周期很短暂。但是堆区和静态存储区的生命周期相当于与程序的生命同时存在(如果您不在程序运行中间将堆内存delete的话),我们将这种变量或数据成为全局变量或数据。但是,对于堆区的内存空间使用更加灵活,因为它允许你在不需要它的时候,随时将它释放掉,而静态存储区将一直存在于程序的整个生命周期中。

      我们此专题仅仅是简要的分析了内存基本构成以及使用它们时需要注意的问题。对内存的分析和讨论将一直贯穿于我们以后所有的专题,这也就是为什么把它作为第一讲的原因。

      编辑特别推荐:

      20099月全国计算机等级考试真题及答案

      20099月全国计算机等级考试成绩查询

    C++中,堆、栈、自由存储区、全局/静态存储区和常量存储区的区别

    C++中,内存分成5个区,他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
    栈,就是那些由编译器在需要的时候分配,在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。
    堆,就是那些由new分配的内存块,他们的释放编译器不去管,由我们的应用程序去控制,一般一个new就要对应一个delete。如果程序员没有释放掉,那么在程序结束后,操作系统会自动回收。
    自由存储区,就是那些由malloc等分配的内存块,他和堆是十分相似的,不过它是用free来结束自己的生命的。
    全局/静态存储区,全局变量和静态变量被分配到同一块内存中,在以前的C语言中,全局变量又分为初始化的和未初始化的,在C++里面没有这个区分了,他们共同占用同一块内存区。
    常量存储区,这是一块比较特殊的存储区,他们里面存放的是常量,不允许修改(当然,你要通过非正当手段也可以修改,而且方法很多)
    明确区分堆与栈
    bbs上,堆与栈的区分问题,似乎是一个永恒的话题,由此可见,初学者对此往往是混淆不清的,所以我决定拿他第一个开刀。
    首先,我们举一个例子:
    void f() { int* p=new int[5]; }
    这条短短的一句话就包含了堆与栈,看到new,我们首先就应该想到,我们分配了一块堆内存,那么指针p呢?他分配的是一块栈内存,所以这句话的意思就是:在栈内存中存放了一个指向一块堆内存的指针p在程序会先确定在堆中分配内存的大小,然后调用operatornew分配内存,然后返回这块内存的首地址,放入栈中,他在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
    这里,我们为了简单并没有释放内存,那么该怎么去释放呢?是deletep么?澳,错了,应该是delete[]p,这是为了告诉编译器:我删除的是一个数组,VC6就会根据相应的Cookie信息去进行释放内存的工作。
    好了,我们回到我们的主题:堆和栈究竟有什么区别?
    主要的区别由以下几点:
    1
    、管理方式不同;
    2
    、空间大小不同;
    3
    、能否产生碎片不同;
    4
    、生长方向不同;
    5
    、分配方式不同;
    6
    、分配效率不同;
    管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生memoryleak
    空间大小:一般来讲在32位系统下,堆内存可以达到4G的空间,从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲,一般都是有一定的空间大小的,例如,在VC6下面,默认的栈空间大小是1M(好像是,记不清楚了)。当然,我们可以修改:
    打开工程,依次操作菜单如下:Project->Setting->Link,在Category中选中Output,然后在Reserve中设定堆栈的最大值和commit
    注意:reserve最小值为4Bytecommit是保留在虚拟内存的页文件里面,它设置的较大会使栈开辟较大的值,可能增加内存的开销和启动时间。
    碎片问题:对于堆来讲,频繁的new/delete势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。对于栈来讲,则不会存在这个问题,因为栈是先进后出的队列,他们是如此的一一对应,以至于永远都不可能有一个内存块从栈中间弹出,在他弹出之前,在他上面的后进的栈内容已经被弹出,详细的可以参考数据结构,这里我们就不再一一讨论了。
    生长方向:对于堆来讲,生长方向是向上的,也就是向着内存地址增加的方向;对于栈来讲,它的生长方向是向下的,是向着内存地址减小的方向增长。
    分配方式:堆都是动态分配的,没有静态分配的堆。栈有2种分配方式:静态分配和动态分配。静态分配是编译器完成的,比如局部变量的分配。动态分配由alloca函数进行分配,但是栈的动态分配和堆是不同的,他的动态分配是由编译器进行释放,无需我们手工实现。

    .
    分配效率:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。堆则是C/C++函数库提供的,它的机制是很复杂的,例如为了分配一块内存,库函数会按照一定的算法(具体的算法可以参考数据结构/操作系统)在堆内存中搜索可用的足够大小的空间,如果没有足够大小的空间(可能是由于内存碎片太多),就有可能调用系统功能去增加程序数据段的内存空间,这样就有机会分到足够大小的内存,然后进行返回。显然,堆的效率比栈要低得多。
    从这里我们可以看到,堆和栈相比,由于大量new/delete的使用,容易造成大量的内存碎片;由于没有专门的系统支持,效率很低;由于可能引发用户态和核心态的切换,内存的申请,代价变得更加昂贵。所以栈在程序中是应用最广泛的,就算是函数的调用也利用栈去完成,函数调用过程中的参数,返回地址,EBP和局部变量都采用栈的方式存放。所以,我们推荐大家尽量用栈,而不是用堆。
    虽然栈有如此众多的好处,但是由于和堆相比不是那么灵活,有时候分配大量的内存空间,还是用堆好一些。
    无论是堆还是栈,都要防止越界现象的发生(除非你是故意使其越界),因为越界的结果要么是程序崩溃,要么是摧毁程序的堆、栈结构,产生以想不到的结果,就算是在你的程序运行过程中,没有发生上面的问题,你还是要小心,说不定什么时候就崩掉,那时候debug可是相当困难的:)
    对了,还有一件事,如果有人把堆栈合起来说,那它的意思是栈,可不是堆,呵呵,清楚了?







    堆栈

    百科名片

    §

    在计算机领域,堆栈是一个不容忽视的概念,但是很多人甚至是计算机专业的人也没有明确堆栈其实是两种数据结构。堆栈都是一种数据项按序排列的数据结构,只能在一端(称为栈顶(top))对数据项进行插入和删除。要点:堆:顺序随意栈:后进先出(Last-In/First-Out)

    目录

    堆和栈的区别§

      1. 堆和栈的理论知识§1.申请方式§

      2. 2.申请后系统的响应§

      3. 3.申请大小的限制§

      4. 4.申请效率的比较§

      5. 5.堆和栈中的存储内容§

      6. 6.存取效率的比较§

      7. 7.小结:§


    堆和栈的主要分别:§

    补充§

    堆和栈的区别§

      1. 堆和栈的理论知识§1.申请方式§

      2. 2.申请后系统的响应§

      3. 3.申请大小的限制§

      4. 4.申请效率的比较§

      5. 5.堆和栈中的存储内容§

      6. 6.存取效率的比较§

      7. 7.小结:§


    堆和栈的主要分别:§

    补充§

    展开

    编辑本段堆和栈的区别

    一、预备知识程序的内存分配  一个由C/C++编译的程序占用的内存分为以下几个部分  

    1、栈区(stack编译器自动分配释放,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。  

    2、堆区(heap由程序员分配释放,若程序员不释放,程序结束时可能由OS回收。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表  

    3、全局区(静态区)(static全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。  

    4、文字常量区常量字符串就是放在这里的,程序结束后由系统释放   5、程序代码区存放函数体的二进制代码。  

    二、例子程序  

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

    //main.cpp  

    inta = 0; 全局初始化区  

    char*p1; 全局未初始化区  

    main()  

    {  

    intb;   

    chars[] = "abc";   

    char*p2;   

    char*p3 = "123456"; 123456\0在常量区,p3在栈上。  

    staticint c =0全局(静态)初始化区  

    p1= (char *)malloc(10);   

    p2= (char *)malloc(20);   

    }  

    分配得来得1020字节的区域就在堆区。  

    strcpy(p1,"123456"); 123456\0放在常量区,编译器可能会将它与p3所指向的"123456"优化成一个地方。

    堆和栈的理论知识

    1.申请方式

    stack:  

    由系统自动分配。例如,声明在函数中一个局部变量intb; 系统自动在栈中为b开辟空间  

    heap:  

    需要程序员自己申请,并指明大小,在cmalloc函数

    p1= (char *)malloc(10);   

    C++中用new运算符

    p2= new char[20];//(char *)malloc(10);   

    但是注意p1p2本身是在栈中的。

    2.申请后系统的响应

    栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。  

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

    3.申请大小的限制

    栈:在Windows,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。  

    堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。

    4.申请效率的比较

    栈由系统自动分配,速度较快。但程序员是无法控制的。  

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

    5.堆和栈中的存储内容

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

    6.存取效率的比较

      chars1[] = "aaaaaaaaaaaaaaa";

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

    #include  

    voidmain()   

    {  

    chara = 1;   

    charc[] = "1234567890";   

    char*p ="1234567890";   

    a= c[1];   

    a= p[1];   

    return;  

    }  

    对应的汇编代码  

    10:a = c[1];  

    004010678A 4D F1 mov cl,byte ptr [ebp-0Fh]   

    0040106A88 4D FC mov byte ptr [ebp-4],cl   

    11:a = p[1];   

    0040106D8B 55 EC mov edx,dword ptr [ebp-14h]   

    004010708A 42 01 mov al,byte ptr [edx+1]   

    0040107388 45 FC mov byte ptr [ebp-4],al   

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

    7.小结:

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

    编辑本段堆和栈的主要分别:

      操作系统方面的堆和栈,如上面说的那些,不多说了。  还有就是数据结构方面的堆和栈,这些都是不同的概念。这里的堆实际上指的就是(满足堆性质的)优先队列的一种数据结构,第1个元素有最高的优先权;栈实际上就是满足后进先出的性质的数学或数据结构。  虽然堆栈,堆栈的说法是连起来叫,但是他们还是有很大区别的,连着叫只是由于历史的原因。

    堆与栈的分布

    编辑本段补充

    堆栈是一种存储部件,即数据的写入跟读出不需要提供地址,而是根据写入的顺序决定读出的顺序




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

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

    chars[] = "abc";

    char*p2;

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

    chars1[] = "aaaaaaaaaaaaaaa";
    char *s2 ="bbbbbbbbbbbbbbbbb";
    aaaaaaaaaaa
    是在运行时刻赋值的;
    bbbbbbbbbbb是在编译时就确定的;
    但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。
    比如:
    #include<stdio.h>;
    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]
    0040106A88 4D FC mov byte ptr [ebp-4],cl
    11: a = p[1];
    0040106D 8B 55EC 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
    小结:
    堆和栈的区别可以用如下的比喻来看出:
    使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。
    使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。

    堆和栈的区别主要分:
    操作系统方面的堆和栈,如上面说的那些,不多说了。
    还有就是数据结构方面的堆和栈,这些都是不同的概念。这里的堆实际上指的就是(满足堆性质的)优先队列的一种数据结构,第1个元素有最高的优先权;栈实际上就是满足先进后出的性质的数学或数据结构。
    虽然堆栈,堆栈的说法是连起来叫,但是他们还是有很大区别的,连着叫只是由于历史的原因。



    展开全文
  • 操作系统的内存分配与回收连续存储管理主要介绍了,内存管理中连续存储管理的三种方法,重点掌握动态分区分配分配算法。 主要的重点冷月做出了标识,知识点如下图(pdf版或xmind源文件请私聊我:操作系统)。 ...
  • 把连续分配方式进一步分为单一连续分配、固定分区分配、动态分区分配以及动态重定位分区分配四种方式。 单一连续分配 这是最简单的一种存储管理方式,但只能用于单用户、单任务的操作系统中。采用这种存储...
  • 给变量分配内存空间可分为静态内存分配和动态内存分配。 静态内存分配属于编译时给变量分配的空间,动态分配属于在程序运行时给变量分配的空间 静态分配属于栈分配,动态分配属于堆分配 运行效率上,静态内存比动态...
  • 单一连续分配:内存分为系统区和用户区,只有一道用户程序占据整个用户区,无外部碎片,有内部碎片,内存利用率低固定分区分配:分为系统区和用户区,用户区划分多个分区,每个分区一个程序,无外部碎片,有内部碎片,利用率低 ...
  • C++内存分配

    2012-11-26 22:48:47
    编程内存在基本上分为这样的几大部分:静态存储区、堆区和栈区。他们的功能不同,对他们使用方式也就不同。 静态存储区:内存在程序编译的...栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容
  • C++程序内存分配

    2018-07-06 23:53:36
    在现代的操作系统中,当我们说到内存,往往需要分两部分来讲:物理...从低地址到高地址,可分为下面几段: 预留内存地址(操作系统维护的内存地址,不可访问) 程序代码区(只读,存代码和一些其他的东西); dat...
  • C++中内存分配详解

    2015-04-08 14:08:22
    下面介绍C++程序设计中的内存分配。 一、内存基本构成 编程内存在基本上分为这样的几大部分:静态存储区、堆区和栈区。他们的功能不同,对他们使用方式也就不同。 静态存储区:内存在程序编译的时候就...
  • C++的内存分配

    2014-05-20 10:29:58
    一、内存基本构成 编程内存在基本上分为这样的几大部分:静态存储区、堆区和栈区。他们的功能不同,对他们使用方式也就不同。 静态存储区:内存在程序编译的时候就已经分配好,...栈内存分配运算内置于处理器的指令集
  • C/C++ 程序内存分配

    2019-04-13 08:36:54
    程序的内存分配 一个由C/C++编译器编译的程序占用的内存可分为如下几个部分: 栈区(Stack): 由编译器自动分配和释放,存放函数的参数值,局部变量值等,其操作方式类似于数据结构中的栈,先进后出; 堆区(Heap): ...
  • 代码段:代码段是用来存放执行文件的操作指令。...++编译器将计算机内存分为代码区和数据区,很显然,代码区就是存放程序代码,而数据区则是存放程序编译和执行过程出现的变量和常量。数据区又分
  • Linux内核动态内存分配

    千次阅读 2013-09-23 09:49:19
    内存分配按其对象大致可分为三类:1. 连续页框;2. 专用或通用对象;3. 非连续的内存区。如果所请求的内存区得以满足,将返回一个页描述符地址或线性地址;否则,返回NULL。 第一类:连续页框【Buddy Allocator】...
  • 编程内存在基本上分为这种几大部分:静态存储区、堆区和栈区。他们的功能不同,对他们使用方式也就不同。 静态存储区:内存在程序编译的时候就已经分配好,这块内存在程序的整个执行...栈内存分配运算内置于处理...
  • String的内存分配机制

    2016-09-13 22:15:28
    今天,我想从string来分析jvm内存分配机制,java数据类型从整体上讲,大概可以分为基础类型和引用类型。首先从string的性质开始讲,string是final类这也就确定它是不变得和不继承。我们知道,string有3种定义...
  • 理解内存分配原理,特别是以页面为单位的虚拟内存分配方法。模拟存储管理中内存空间的管理和分配内存空间的管理分为固定分区管理方式变分区管理方式,页式存储管理,段式存储管理。
  • 内存管理可分为四部分 内存地址的转换(逻辑地址到物理地址) 1.绝对装入(早期单道批操作系统) 2.静态重定位(多道批操作系统) 3.动态重定位 内存的扩充(虚拟内存内存的保护 内存分配与回收 1.连续分配...
  • 下面介绍C++程序设计中的内存分配。 一、内存基本构成 编程内存在基本上分为这样的几大部分:静态存储区、堆区和栈区。他们的功能不同,对他们使用方式也就不同。 静态存储区:内存在程序编译的时候就...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 626
精华内容 250
关键字:

内存分配方式可分为