当前位置:   article > 正文

堆和栈的区别(面试经验总结)_c++的栈区对象,堆区对象的区别

c++的栈区对象,堆区对象的区别

C++中,内存分为5个区:堆、栈、自由存储区、全局/静态存储区和常量存储区。

栈:是由编译器在需要时自动分配,不需要时自动清除的变量存储区。通常存放局部变量、函数参数等。
堆:是由new分配的内存块,由程序员释放(编译器不管),一般一个new与一个delete对应,一个new[]与一个delete[]对应。如果程序员没有释放掉,        资源将由操作系统在程序结束后自动回收。

自由存储区:是由malloc等分配的内存块,和堆十分相似,用free来释放。
全局/静态存储区:全局变量和静态变量被分配到同一块内存中(在C语言中,全局变量又分为初始化的和未初始化的,C++中没有这一区分)。
常量存储区:这是一块特殊存储区,里边存放常量,不允许修改。
(注意:堆和自由存储区其实不过是同一块区域,new底层实现代码中调用了malloc,new可以看成是malloc智能化的高级版本)

一. 堆与栈的讨论:
 管理方式:堆中资源由程序员控制(容易产生memory leak), 栈资源由编译器自动管理,无需手工控制。
 系统响应:对于堆,应知道系统有一个记录空闲内存地址的链表当系统收到程序申请时,遍历该链表,寻找第一个空间大于申请空间的堆结点,删 除空闲结点链表中的该结点,并将该结点空间分配给程序(大多数系统会在这块内存空间首地址记录本次分配的大小,这样delete才能正确释放本内存  空间,另外系统会将多余的部分重新放入空闲链表中)。对于栈,只要栈的剩余空间大于所申请空间,系统为程序提供内存,否则报异常提示栈出。
 空间大小: 堆是不连续的内存区域(因为系统是用链表来存储空闲内存地址,自然不是连续的),堆大小受限于计算机系统中有效的虚拟内存(32bit  系统理论上是4G),所以堆的空间比较灵活,比较大。栈是一块连续的内存区域,大小是操作系统预定好的,windows下栈大小是2M(也有是1M,在  编译时确定,VC中可设置)。
 碎片问题:对于堆,频繁的new/delete会造成大量碎片,使程序效率降低。 对于栈,它是一个先进后出的队列,进出一一对应,不会产生碎片。
 生长方向堆向上,向高地址方向增长。栈向下,向低地址方向增长。
 分配方式: 堆都是动态分配(没有静态分配的堆)。栈有静态分配和动态分配,静态分配由编译器完成(如局部变量分配),动态分配由alloca函数分配,但栈的动态分配的资源由编译器进行释放,无需程序员实现。

 分配效率:堆由C/C++函数库提供,机制很复杂。所以堆的效率比栈低很多。栈是极其系统提供的数据结构计算机在底层对栈提供支持,分配专门  寄存  器存放栈地址,栈操作有专门指令

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

 

堆和栈的区别可以用如下的比喻来看出:

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

下面就小姐一下java中的堆和栈和c++中略有不同描述偶这使用的酵素来说,先了解JVM(虚拟机)内存的划分:

      Java程序在运行时都要开辟空间,任何软件在运行时都要在内存中开辟空间,Java虚拟机运行时也是要开辟空间的。JVM运行时在内存中开辟一片内存区域,启动时在自己的内存区域中进行更细致的划分,因为虚拟机中每一片内存处理的方式都不同,所以要单独进行管理。

      JVM内存的划分有五片: 1.   寄存器;2.   本地方法区;  3.   方法区;  4.   栈内存;  5.   堆内存。

堆(Heap)

     Java堆是被所有线程共享的一块内存区域,在虚拟机启动时创建;

     Java虚拟机规范描述:所有的对象实例及数组都要在堆上分配;

     Java堆可以处于物理上不连续的内存空间,只要逻辑上连续即可;

     (线程共享)堆内存中的对象对所有线程可见。堆内存中的对象可以被所有线程访问;

     (异常提示)如果是堆内存没有可用的空间存储生成的对象,JVM会抛出java.lang.OutOfMemoryError;

     (内存分配)动态分配内存

栈(Stack)

    存放基本类型的数据和对象的引用,即存放变量;

       如果存放的是基本类型数据(非静态变量),则直接将变量名和值存入stack中的内存中;

    如果是引用类型,则将变量名存入栈,然后指向它new出的对象(存放在堆中);

     (线程私有)栈内存归属于单个线程,每个线程都会有一个栈内存,其存储的变量只能在其所属线程中可见,即栈内存可以理解成线程的私有内存;

     (内存分配)栈的内存要远远小于堆内存,如果你使用递归的话,那么你的栈很快就会充满。如果递归没有及时跳出,很可能发生StackOverFlowError问题;

     (异常提示)如果栈内存没有可用的空间存储方法调用和局部变量,JVM会抛出java.lang.StackOverFlowError;

     (内存分配)内存分配固定;

     存取速度比堆要快,仅次于寄存器,栈数据可以共享;

       我们重点来说一下堆和栈:

       栈内存:栈内存首先是一片内存区域,存储的都是局部变量,凡是定义在方法中的都是局部变量(方法外的是全局变量),for循环内部定义的也是局部变量,是先加载函数才能进行局部变量的定义,所以方法先进栈,然后再定义变量,变量有自己的作用域,一旦离开作用域,变量就会被释放。栈内存的更新速度很快,因为局部变量的生命周期都很短。

       堆内存:存储的是数组和对象(其实数组就是对象)凡是new建立的都是在堆中,堆中存放的都是实体(对象),实体用于封装数据,而且是封装多个(实体的多个属性),如果一个数据消失,这个实体也没有消失,还可以用,所以堆是不会随时释放的,但是栈不一样,栈里存放的都是单个变量,变量被释放了,那就没有了。堆里的实体虽然不会被释放,但是会被当成垃圾,Java有垃圾回收机制不定时的收取。

      下面我们通过一个图例详细讲一下堆和栈:

      比如主函数里的语句   int [] arr=new int [3];在内存中是怎么被定义的:

      主函数先进栈,在栈中定义一个变量arr,接下来为arr赋值,但是右边不是一个具体值,是一个实体。实体创建在堆里,在堆里首先通过new关键字开辟一个空间,内存在存储数据的时候都是通过地址来体现的,地址是一块连续的二进制,然后给这个实体分配一个内存地址。数组都是有一个索引,数组这个实体在堆内存中产生之后每一个空间都会进行默认的初始化(这是堆内存的特点,未初始化的数据是不能用的,但在堆里是可以用的,因为初始化过了,但是在栈里没有),不同的类型初始化的值不一样。所以堆和栈里就创建了变量和实体:

                                                 

     那么堆和栈是怎么联系起来的呢?

     我们刚刚说过给堆分配了一个地址,把堆的地址赋给arr,arr就通过地址指向了数组。所以arr想操纵数组时,就通过地址,而不是直接把实体都赋给它。这种我们不再叫他基本数据类型,而叫引用数据类型。称为arr引用了堆内存当中的实体。(可以理解为c或c++的指针,Java成长自c++和c++很像,优化了c++)                                                               

     

              如果当int [] arr=null;

              arr不做任何指向,null的作用就是取消引用数据类型的指向。

              当一个实体,没有引用数据类型指向的时候,它在堆内存中不会被释放,而被当做一个垃圾,在不定时的时间内自动回收,因为Java有一个自动回收机制,(而c++没有,需要程序员手动回收,如果不回收就越堆越多,直到撑满内存溢出,所以Java在内存管理上优于c++)。自动回收机制(程序)自动监测堆里是否有垃圾,如果有,就会自动的做垃圾回收的动作,但是什么时候收不一定。

             所以堆与栈的区别很明显:

            1.栈内存存储的是局部变量而堆内存存储的是实体;

            2.栈内存的更新速度要快于堆内存,因为局部变量的生命周期很短;

            3.栈内存存放的变量生命周期一旦结束就会被释放,而堆内存存放的实体会被垃圾回收机制不定时的回收。

附 栈数据共享

   栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义:

     int a = 3;

     int b = 3;

   编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用,然后查找栈中是否有3这个值,如果没找到,就将3存放进来,然后将a指向3。接着处理int b = 3;在创建完b的引用变量后,因为在栈中已经有3这个值,便将b直接指向3。这样,就出现了a与b同时均指向3的情况。

   这时,如果再令a=4;那么编译器会重新搜索栈中是否有4值,如果没有,则将4存放进来,并令a指向4;如果已经有了,则直接将a指向这个地址。因此a值的改变不会影响到b的值。

   要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的,因为这种情况a的修改并不会影响到b, 它是由编译器完成的,它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态,会影响到另一个对象引用变量。

   String是一个特殊的包装类数据。可以用:

   String str = new String("abc");

   String str = "abc";

  两种的形式来创建,第一种是用new()来新建对象的,它会在存放于堆中。每调用一次就会创建一个新的对象。

而第二种是先在栈中创建一个对String类的对象引用变量str,然后查找栈中有没有存放"abc",如果没有,则将"abc"存放进栈,并令str指向”abc”,如果已经有”abc”则直接令str指向“abc”。

   比较类里面的数值是否相等时,用equals()方法;当测试两个包装类的引用是否指向同一个对象时,用==,下面用例子说明上面的理论。

   String str1 = "abc";

   String str2 = "abc";

   System.out.println(str1==str2); //true

   可以看出str1和str2是指向同一个对象的。

   String str1 =new String ("abc");

   String str2 =new String ("abc");

   System.out.println(str1==str2); // false

   用new的方式是生成不同的对象。每一次生成一个。

   因此用第一种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已. 这种写法有利于节省内存空间. 同时它可以在一定程度上提高程序的运行速度,因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc");的代码,则一概在堆中创建新对象,而不管其字符串值是否相等,是否有必要创建新对象,从而加重了程序的负担。

   另一方面, 要注意: 我们在使用诸如String str = "abc";的格式定义类时,总是想当然地认为,创建了String类的对象str。担心陷阱!对象可能并没有被创建!而可能只是指向一个先前已经创建的 对象。只有通过new()方法才能保证每次都创建一个新的对象。

   由于String类的immutable性质,当String变量需要经常变换其值时,应该考虑使用StringBuffer(线程安全,效率低)类,以提高程序效率。

引用:

剑指Offer——简述堆和栈的区别_IT全栈 华强工作室-CSDN博客_堆和栈的区别

堆和栈的概念和区别_pt666的博客-CSDN博客_堆和栈的区别

C++堆和栈的区别和联系_yangyongUestc的博客-CSDN博客_c++堆和栈

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/469901
推荐阅读
相关标签
  

闽ICP备14008679号