精华内容
下载资源
问答
  • 浅谈堆、堆区区的概念和区别

    万次阅读 多人点赞 2019-10-21 15:45:15
    注:首先可以分为两种,一种是数据结构,另一种是和内存的分配有关,这两种虽然都有,但是两者关系并不大, 1、是数据结构里面的叫法,注意:有时候有人喜欢这样说 "堆栈" 其实说的就是而不是...

    在以前小编我对于这几个名词真的是分不清,感觉好像都一样,因为概念很抽象,不知道大家有没有这样觉得,所以我觉得有必要要对它进行区分下,让大家对它起码有宏观的认识。

    一、区别

    注:首先堆和栈可以分为两种,一种是数据结构,另一种是和内存的分配有关,这两种虽然都有栈和堆,但是两者关系并不大,

    1、栈、堆是数据结构里面的叫法,注意:有时候有人喜欢这样说 "堆栈" 其实说的就是栈而不是堆。  

     2、堆区、栈区则是内存模型的叫法。

     

    二、内存中的栈区和堆区

    我们知道php的底层是C (任何语言其实都可以分为大同小异的几块)

    而C语言的内存模型分为5个区:栈区、堆区、静态区、常量区、代码区。每个区存储的内容如下:

    1、栈区:存放函数的参数值、局部变量等,由编译器自动分配和释放,通常在函数执行完后就释放了,其操作方式类似于数据结构中的栈。栈内存分配运算内置于CPU的指令集,效率很高,但是分配的内存量有限,比如iOS中栈区的大小是2M。

    2、堆区:就是通过new、malloc、realloc分配的内存块,编译器不会负责它们的释放工作,需要用程序区释放。分配方式类似于数据结构中的链表。“内存泄漏”通常说的就是堆区。

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

    4、常量区:常量存储在这里,不允许修改。

    5、代码区:顾名思义,存放代码。

     

    分布图:

     

    栈区和堆区大小差异?

    栈区:由图中其实可以知道,栈区是向低地址扩展的,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,大小在进程分配时是确定的,具体大小看编译器,操作系统。所需大小一般小于10M!太大没有意义,不符合栈是用来快速存取的目标。

    堆区:堆区是向高地址扩展的,是不连续的内存区域(这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的是动态分配的),因为会手动进行分配,会大一些,大小不固定。

    栈区和堆区效率差异?

    栈区:由系统自动分配,速度较快。但程序员是无法控制的。(只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。)

    堆区:是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便。(首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的 delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中)

    小结:其实从上面的知识我们可以看出,如果存放在堆中的数据如果不进行释放,很可能造成内存泄漏,因为并不一定能触发gc机制回收。所以对于堆中的内存使用,我们要记得用完释放。

     

    三、数据结构中的栈和堆

    什么是数据结构?

    存储与组织数据的方式。我感觉更应强调数据的组织方式,比如好多数据结构的存储方式都是用的数组,但他们根据自身的特点进行了封装,因为存储方式只有顺序存储和链式存储两种,但是却可以组合成多种数据结构。 

     

    常用的数据结构有哪些?

    数组、栈、堆、队列、链表等等。

     

    栈是限定仅仅在表尾进行插入和删除操作的线性表,把允许插入和删除的一端称之为栈顶,另外一端称之为栈底。特点:后进先出,称之为后进先出线性表。

    栈的应用:递归。

     

    是一种经过排序的树形数据结构,每一个节点都有一个值,通常所说堆的数据结构是二叉树,堆的存取是随意的。所以堆在数据结构中通常可以被看做是一棵树的数组对象。而且堆需要满足一下两个性质:
    (1)堆中某个节点的值总是不大于或不小于其父节点的值;
    (2)堆总是一棵完全二叉树。

    堆的应用:堆排序,快速找出最大值、最小值,简化时间复杂度,像这样支持插入元素寻找最大(小)值元素的数据结构称之为优先队列

     

     

    展开全文
  • iOS 三种全局 堆区Block小小解读

    千次阅读 2019-04-12 09:02:15
    堆区 copy到堆空间上。可以在定义的那个范围之外使用。 __NSGlobalBlock__ 全局区 不捕捉任何外部变量,全部信息在编译器就已确定。 自己写的加上学习别人的一点也不详细 时间紧 稍后...

    从2015年接触block就只会用 (还是抄袭别人的)就没真正掌握过这个东西

    a,

    block是啥?

    b,

    哪三种block?

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

    我赶脚自己个开始用block就是用于界面反相传值,比代理少一些代码。

    后来发现一些网络的封装,回调里用到这个东西,挺方便。

    代码块Block是苹果在iOS4开始引入的对C语言的扩展,用来实现匿名函数的特性,Block是一种特殊的数据类型,其可以正常定义变量、作为参数、作为返回值,特殊地,Block还可以保存一段代码,在需要的时候调用,目前Block已经广泛应用于iOS开发中,常用于GCD、动画、排序及各类回调

    注: Block的声明与赋值只是保存了一段代码段,必须调用才能执行内部代码

    =====================================================================================

    block声明

    typedef 用这个使用更方便 格式不能理解就先死记硬背 也许过段时间无师自通了  不知道大家在学习新技术或者新本领的时候有没有这种感受 之前很难理解吃透的东西 不久的某一天就能恍然大悟

    block定义

    有参无参 返回值有参无参

    block调用(自己尝试着恍然大悟吧)

    block内存管理 循环引用(自己尝试着恍然大悟吧)

    三种block

    block的三种类型:全局块、栈块、堆块。

    根据block在内存中的位置,block被分成三种类型:

    类型内存位置介绍
    __NSStackBlock__栈区栈内有效,出栈后销毁。
    __NSMallocBlock__堆区copy到堆空间上。可以在定义的那个范围之外使用。
    __NSGlobalBlock__全局区不捕捉任何外部变量,全部信息在编译器就已确定。

    自己写的加上学习别人的一点也不详细 时间紧 稍后会继续补充

    展开全文
  • 以下是对区和堆区内存分配的区别进行了详细的分析介绍,需要的朋友可以过来参考下
  • C语言进阶 ~ 内存四、全局、代码

    千次阅读 多人点赞 2020-03-05 20:16:42
    1.3.3 堆区(heap) : 一般由程序员分配释放(动态内存申请与释放),若程序员不释放,程序结束时可能由操作系统回收。 1.4 函数的调用模型 1.5 的生长方向和内存存放方向 1.1 数据类型本质分析 1.1.1 ...

    特别声明:该部分是根据B站大佬---什么都想干好的视频学习而来。

    目录

    1.1 数据类型本质分析

    1.1.1 数据类型概念

    1.1.2 数据类型的本质

    1.1.3 数据类型的别名

    1.1.4 数据类型之 void

    1.2 变量的本质分析

    1.2.1 变量的概念

    1.3 程序的内存四区模型

    1.3.1 全局区(全局变量、静态变量(const,constant或final等)、文字常量区)

    1.3.2 栈区(栈区(stack) :① 由编译器自动分配释放,存放函数的参数值,局部变量的值等。② 函数运行时分配,函数结束时释放。由编译器自动分配释放 ,存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。)

    1.3.3 堆区(heap) : 一般由程序员分配释放(动态内存申请与释放),若程序员不释放,程序结束时可能由操作系统回收。

    1.4 函数的调用模型

    1.5 栈的生长方向和内存存放方向


    1.1 数据类型本质分析

    1.1.1 数据类型概念

    • “类型”是对数据的抽象
    •  类型相同的数据有相同的表示形式、存储格式以及相关的操作
    •  程序中使用的所有数据都必定属于某一种数据类型

    1.1.2 数据类型的本质

    • 数据类型可理解为创建变量的模具:是固定内存大小的别名
    • 数据类型的作用:编译器预算对象(变量)分配的内存空间大小。
    •  注意:数据类型只是模具,编译器并没有分配空间,只有根据类型(模具)创建变量(实物),编译器才会分配空间。
    #include <stdio.h>
    
    int main(void)
    {
        int a = 10; //告诉编译器,分配4个字节的内存
        int b[10];  //告诉编译器,分配4*10 = 40 个字节的内存
    
        printf("b:%p, b+1: %p, &b:%p, &b+1: %p\n", b, b + 1, &b, &b + 1);
    
        //b+1 和 &b+1的结果不一样 (+1 ---> +4; +1 ---> +40)
        //是因为 b 和 &b 所代表的数据类型不一样
        //b  代表数组首元素的地址
        //&b 代表整体数组的地址
    
        return 0;
    }
    
    • b+1 和 &b+1的结果不一样 (+1 ---> +4; +1 ---> +40)
    • 是因为 b 和 &b 所代表的数据类型不一样
    • b  代表数组首元素的地址
    • &b 代表整体数组的地址

    1.1.3 数据类型的别名

    ① 给数据类型起别名

    #include <stdio.h>
    
    typedef unsigned int u32;   //给unsigned int类型取别名
    
    int main(void)
    
    {
    
        u32 a;         
    
        a = 10;                 
    
        return 0;                   
    }
    

    ② 给结构体类型起别名

    #include <stdio.h>
    
    #define pi 3.14
    
    // 正常使用结构体 //
    struct People
    {
    	char name[64];
    	int age;
    };
     给结构体类型起别名 
    typedef struct People_2
    {
    	char name[64];
    	int age;
    } people_t;
    
    
    int main(void)
    {
    	// 正常使用结构体 ///的初始化///
    	struct People p1;
    	 给结构体类型起别名 /的初始化///
    	people_t p2;
    
    	p1.age = 10;
    	p2.age = 11;
    
    
    	return 0;
    }

    1.1.4 数据类型之 void

    1、函数参数为空,定义函数时,可以用void修饰: int fun(void)
    2、函数没有返回值: void fun(void);
    3、不能定义vold类型的普通变量, vold a; //err,无法确定类型,不同类型分配空间不一样
    4、 可以定义vold *变量: void *; //ok, 32位是4字节,64位是8字节
    5、数据类型本质:固定内存块大小别名
    6、void和万能指针,函数返回值,函数参数

    • void的字面意思是“无类型”,void *则为“无类型指针”,void *可以指向任何类型的数据。
    • void * memcpy(void *dest, const void *src, size_t len);void指针的意义

    7、void指针的意义

          C语言规定只有相同类型的指针才可以相互赋值

          void*指针作为左值用于“接收”任意类型的指针

          void*指针作为右值赋值给其它指针时需要强制类型转换

          int *p1 = NULL;

          char *p2 = (char *)malloc(sizoeof(char)*20);

    1.2 变量的本质分析

    1.2.1 变量的概念

           概念:既能读又能写的内存对象,称为变量。

    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void)
    {
    	int i = 0;
    
    	// 通过变量直接操作内存
    	i = 10;
    
    	int *p = &i;
    	printf("&i:%d\n", &i);
    	printf("p:%d\n", p);
    
    	// 通过内存编号间接操作内存
    	*p = 100;
    	printf("i = %d, *p = %d\n", i, *p);
    
    	system("pause");
     	return 0;
    }
    

    1.3 程序的内存四区模型

    1.3.1 全局区(全局变量、静态变量(const,constant或final等)、文字常量区)

    #include <stdio.h>
    
    char * getStr1()
    {
        char *p1 = "abcdefg2";
        return p1;
    }
    char *getStr2()
    {
        char *p2 = "abcdefg2";
        return p2;
    }
    int main(void)
    {
        char *p1 = NULL;
        char *p2 = NULL;
        p1 = getStr1();
        p2 = getStr2();
    
        //打印p1 p2 所指向内存空间的数据
        printf("p1:%s , p2:%s \n", p1, p2);
    
        //打印p1 p2 的值
        printf("p1:%p , p2:%p \n", p1, p2);
    
        return 0;
    }
    

    问题:内容一致, 为什么两个指针的地址值也是一样的?
     

    ① 程序执行到   int main(void) 

    ② 程序执行到       char *p1 = NULL;  char *p2 = NULL;

    ③ 程序执行到 getStr1()        由于个人原因在全局区中应该为“abcdefg1\0”

    ④ 程序执行到 p1 = getStr1();   由于个人原因在全局区中应该为“abcdefg1\0”

    ⑤ 程序执行到 p2 = getStr2();    由于个人原因在全局区中应该为“abcdefg1\0”

    因为字符变量是一致的,所以并没有重新放在另一个内存区域,用的是同一个。

    另注意:

        打印p1 p2 所指向内存空间的数据
        printf("p1:%s , p2:%s \n", p1, p2);

        打印p1 p2 的值
        printf("p1:%p , p2:%p \n", p1, p2);

    1.3.2 栈区(栈区(stack) :① 由编译器自动分配释放,存放函数的参数值,局部变量的值等。② 函数运行时分配,函数结束时释放。由编译器自动分配释放 ,存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。)

    #include <stdio.h>
    
    char *get_str(void)
    {
    	char str[] = "abcdedsgads"; //str在栈区,字符常量在全局区
    	printf("在子函数中:str = %s\n", str);
    	return str;
    }
    
    int main(vo1d)
    {
    	char *p = NULL;
    
    	p = get_str();
    	printf("在主函数中:p = %s\n",p);
    	printf("\n");
    	system("pause");
    	return 0;
    }

    请问打印出来的内容一致吗?为什么不一致?

    ① 程序执行到 get_str();  包括第一次打印,到此都是正常的。

    ② 程序执行到 p = get_str();  讲数组的首地址赋值给p,到此也是正常的。

    ③ 程序运行完  p = get_str();  还未运行 printf("在主函数中:p = %s\n",p);时

         注意此时的变化:栈区(stack) :① 由编译器自动分配释放,存放函数的参数值,局部变量的值等。② 函数运行时分配,函数结束时释放。由编译器自动分配释放 ,存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

    ④ 程序运行至打印      打印出来了乱码

     

    1.3.3 堆区(heap) : 一般由程序员分配释放(动态内存申请与释放),若程序员不释放,程序结束时可能由操作系统回收。

    接着栈所说的内容,我们该如何取出这一串字符呢?

    #include <stdio.h>
    #include <String.h>
    
    char *get_str(void)
    {
    	char *p1 = NULL;
    
    	p1 = (char *)malloc(100);
    
    	if (p1 == NULL)
    	{
    		return NULL;
    	}
    	strcpy
    	
    	(p1,"adsagldsjg1k");
    	return p1;
    }
    
    
    int main(vo1d)
    {
    
    	char *p = NULL;
    
    	p = get_str();
    	if (p != NULL) 
    	{
    		printf("在主函数中:p = %s\n",p);
    		free(p);
    		p = NULL;
    	}
    	
    	printf("\n");
    	system("pause");
    	return 0;
    }
    

    ① 程序运行至  char *p = NULL;

    ② 程序运行至  get_str();  中的 char *p1 = NULL;

    ③ 程序运行至 p1 = (char *)malloc(100);

    ④ 程序运行到 strcpy(p1,"adsagldsjg1k");

    ⑤ 程序运行到  p = get_str();

    ⑥ 程序运行到  printf("在主函数中:p = %s\n",p);

    ⑦ free(p); 只是解除了程序对于堆区地址0x20的使用权,并没有将0x20处的数据清除。

    1.4 函数的调用模型

    1.5 栈的生长方向和内存存放方向

    #include <stdio.h>
    
    int main(void)
    {
        int a;
        int b;
    
        char buf[4];
    
        printf("&a: %p\n", &a);
        printf("&b: %p\n", &b);
    
        printf("buf的地址 : %p\n", &buf[0]);
        printf("buf+1地址: %p \n", &buf[1]);
    
        return 0;
    }
    

     

    展开全文
  • 堆区区、全局静态区的理解

    千次阅读 2018-07-01 20:01:38
    堆区的申请是动态的,可通过用户传入的参数申请指定长度的内存空间,堆的内存也是很大,可以看成当前后台空闲的内存大小,可以通过new,malloc,calloc,realloc申请,回收的方式是delete或者free。 堆区的地址是从...

    1、栈区:

    #include<stdio.h>
    
    int main(void) {
    	int x = 2;    				//在栈上面申请一个int类型长度的空间
    	int y[] = {1,2,3};   		//在栈上面申请一个int类型数组长度为3的一段空间
    	char s[] = {"132423"};		//在栈上面申请一个char类型数组长度为6的一段空间
    	printf("x_address = %p\n", &x);
    	printf("y_address = %p\n", &y);
    	printf("s_address = %p\n", s);
    	return 0;
    }

    可以通过输出地址看一下上述几个变量的地址变化。


    比如上面代码中变量的定义都是在栈上面建立的,在栈上面申请变量由编译器自动分配释放,存放函数的参数值、局部变量的值等,定义的变量出了作用范围之后会由编译器自动释放,栈的大小一般是2M或者1M,一个int是4个字节,2M的大小就是2M=2*1024K = 2 * 1024*1024 B,这么多个字节。 栈里面的地址是向低地址扩展的,可以想象成从栈底向栈顶消耗栈空间。在栈里面分配空间的优点是:分配速度快,不用担心用完了回收的事情。缺点就是:整个栈的空间大小太小了,拿2M的大小来算,就能放int类型的数据2 * 1024*1024 / 4 = 524288个,所以栈的地方很适合函数局部变量,不必担心回收的问题,不适合申请很大的空间。

    补充一个在栈里面动态申请的函数alloca,是今天在书《c专家编程》中看到的,此函数申请字节长度为t的空间,返回一个指针,是在栈上面申请的,用完之后自动回收。

    但是这种方法并不适用于那些比创建它们的函数生命期更长的结构。如果对象的生命期在该函数结束前便已终止,这种在栈上面的动态分配是一个不错的选择。

    void *alloca(size_t t);
    int count;
    scanf("%d", &count);
    int *array1 = (int *)alloca(sizeof(int) * count);

    2、堆区

    #include<stdio.h>
    #include<malloc.h>
    
    int main(void) {
    	int *array1  = NULL;
    	int count = 5;
    	int i;
     
    	array1 = (int *)calloc(sizeof(int), count);   //在堆上面申请一段长度为sizeof(int)*count空间给array1指针
    	for(i = 0; i < count; i++) {
    		printf("%p\n", &array1[i]);
    	}
    
    	free(array1);
    
    	return 0;
    }

    堆区的申请是动态的,可通过用户传入的参数申请指定长度的内存空间,堆的内存也是很大,可以看成当前后台空闲的内存大小,可以通过new,malloc,calloc,realloc申请,回收的方式是delete或者free。堆区的地址是从低向高扩展的。

    每次需要申请一段内存空间的时候,会在当前的内存里面找一段连续的内存合适大小分配给这个指针,至于分配的算法有几种:最佳适应、最差适应、首次适应。

    最佳适应算法和最差适应算法是反过来的,这两种算法对当前空间的内存块都是按照大小排序,最差适应是分配了最大的内存,最佳适应是分配了刚好合适的内存块。而首次适应不用对空闲区排序,只要找到一个满足需求大小的空闲分区,就分配。

    通常动态在堆上面分配的内存,比如一个长度为10的int类型数组,应该占用字节数是40个,但实际上是申请了40 的下一个2的次方数,也就是64,它会圆整为下一个大于申请数量的2的整数次方,申请的长度是64字节长度。16个int的长度。所以一旦发生内存泄漏,忘记手动释放申请的空间,造成泄漏的内存要比忘记释放的那个的数据结构更大。 

    在堆上申请空间的优点:堆的空间大、只要有足够的空闲空间可申请任意大小的空间。

    缺点:动态申请的空间必须记得写释放函数操作,否则就会造成严重而且很难察觉的内存泄漏!!野指针!!

    array1 = (int *)calloc(sizeof(int), 10);

    3、全局/静态区

    static修饰或者全局的变量放在这里,全局静态区的空间大小和堆的大小差不多。

    其中初始化的变量和未初始化变量存放的不是一个位置。未初始化的变量放在未初始化数据区(BBS),这个区域用来存放程序中未初始化的全局/静态变量的一块内存区域。

    对于这一部分的理解,可以把静态变量和全局变量归为一类理解,不过在c里面的语法要求,static可以用来修饰一个局部变量,java里面的static修饰变量必须是在全局下的,是一个类的成员,函数里面static修饰变量一定报错。

    #include<stdio.h>
    
    int x = 2;   	//全局变量初始化过的
    int y;			//全局变量未初始化
    
    
    int main(void) {
    	static int z = 2;			//静态变量初始化过的
    	static int z2;				//静态变量未初始化的
    
    	printf("x: %p\n", &x);
    	printf("y: %p\n", &y);
    	printf("z: %p\n", &z);
    	printf("z2: %p\n", &z2);
    
    	return 0;
    }

    4、字符常量区

    char *s1 = "1234";  //常量 不可更改

    这种方式申请的是一个字符常量,不可更改,相同的内容在内存中只占一份空间,上述就是一个字符常量,字符常量区在全局静态区的一部分,但没有和全局静态变量挨在一起。

    下面的代码中虽然有多个字符串,s1,s2,s3,但是这三个字符串在内存中的地址绝对是相同的,并且字符串是不可更改的,这个常量是字符常量,和const修饰的变量还不一样,就算const int a = 2这样子这个a还是在栈上而不是在字符常量区。

    #include<stdio.h>
    
    char *s3 = "1234";   //存放字符常量区 相同内容只占一份内存
    
    int main(void) {
    	char *s1 = "1234";
          char *s2 = "1234";
    printf("s1 = %p\n", s1);printf("s2 = %p\n", s2);printf("s3 = %p\n", s3);return 0;}


    5、程序代码区:程序代码区,用于存放程序的二进制代码的空间,这一部分不是很理解。


    对比各内存区 

    #include<stdio.h>
    #include<malloc.h>
    
    int x1;					//未初始化的全局变量 在bss区
    int x2 = 2;				//初始化的全局变量 在全局静态区
    char *s3 = "12345678";   	//存放在字符常量区 并且相同内容只占一份内存 并且发现了在全局区放了一个指针 指向字符常量区 占四个字节
    
    // 在c里面未初始化的全局变量 和初始化的全局变量是放在一块的
    // 而在c++里面初始化和非初始化变量不在一起
    
    int main(void) {
    	static int x3 = 3;		//初始化的静态变量 在全局静态区 和上面的x2应该是挨在一起的
    	static int x5;			//未初始化的静态变量 在bss区
    	char *s1 = "12345678";		//存放在字符常量区 并且相同内容只占一份内存
    	char *s2 = "12345678";		//存放在字符常量区 并且相同内容只占一份内存
      	const  int x4 = 4;  	//这个也是放在栈区的 而不是在字符常量区
      	int *array = NULL;
      	int i;
            int str[] = {12345678"};        //这是在栈上的 和上面的字符串没有关系
      	array = (int *)calloc(sizeof(int), 5);  	//在堆上申请一段长度为sizeof(int)*5的内存给array指针
    
    	printf("x1 = %p\n", &x1);
    	printf("x2 = %p\n", &x2);
    	printf("x3 = %p\n", &x3);
    	printf("x4 = %p\n", &x4);
    	printf("x5 = %p\n", &x5); 
    
    	printf("s1 = %p\n", s1);
    	printf("s2 = %p\n", s2);
    	printf("s3 = %p\n", s3);
    
    	for(i =0; i < 5; i++) {
    		printf("%p ", array++);
    	}
    
    	free(array);			//释放在堆上面申请的空间
    	array = NULL;
    
    	return 0;
    }

    输出结果:




    关于全局静态变量未初始化的,是要放在一起未初始化的区域,但至于为啥不是连续的,中间的内存的内容应该是放了其他的变量引用什么的。

    展开全文
  • C++中堆区 常量区

    千次阅读 2018-07-14 19:15:37
    #include&lt;...abc在常量,c在上。char* d="abc"; 编译器可能会将它与c所指向的"abc"优化成一个地方。const char e[]="abc"; const char f[]="abc
  • 在执行一个C/C++语言程序时,此程序将拥有唯一的“内存四区”——区、堆区、全局区、代码区。每个程序都有唯一的四个内存区域,我们需要熟悉和了解各个区域的特性,例如存储什么类型的数据, 有谁去申请开辟,,又...
  • ,方法

    千次阅读 多人点赞 2018-05-17 20:34:28
    最近在看《深入理解Java虚拟机》,书中给了几个例子,比较好的说明了几种...Java程序运行时,数据会分区存放,JavaStack(Java)、 heap()、method(方法)。1、JavaJava的区域很小,只有1M,特点是存...
  • jvm 内存划分 堆区 方法区

    千次阅读 2016-06-11 19:15:41
    这两天看了一下深入浅出JVM这本书,推荐给高级的java程序员去看,对你了解JAVA的底层和运行机制有 ...堆区: 1.存储的全部是对象,每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令) 2.jvm只有一
  • iOS程序中的内存分配 堆区全局区(转) 在计算机系统中,运行的应用程序的数据都是保存在内存中的,不同类型的数据,保存的内存区域不同。 一、内存分区 区(stack) 由编译器自动分配并释放,存放函数的...
  • 【C】堆区区的区别

    千次阅读 2019-01-26 12:43:45
    一.程序内存的区域 ...1、栈区(stack) 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等,内存的分配是连续的,类似于平时我们所说的,如果还不清楚,那么就把它想成数组,它的...
  • ,方法关系图

    千次阅读 多人点赞 2019-06-09 11:43:15
    下面看这段代码在内存中的分配流程: package test01; public class StackHeadMethod { public static void main(String[] args) { int a = 1; // 在中分配内存空间 String b = "test...
  • 【数据区、代码区、堆区区】

    千次阅读 2019-05-24 16:17:40
    2.堆区(heap):主要用来存储我们创建的对象、动态的申请的临时空间等,堆内数据要及时清理。 3.数据区(data seg):也称全局区或者静态区,常用来存放一些全局的东西,比如我们经常用到的静态变量、全局变量等都会存放...
  • 2、堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回 收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵。 3、全局区(静态区)(static)—,全局变
  • C语言中堆区栈区的区别

    千次阅读 2018-03-14 10:21:10
    平常我们在编程代码的过程中,...在C语言编写代码的过程中,内存分为四区:区、堆区、全局变量区、代码区1)区:由编译器自动分配释放,存放函数的参数,局部变量的值void recevery(char* buf, int bufsize){ ...
  • 什么是代码区、常量区、静态区(全局区)、堆区区? 一直对这些区搞不清楚,每次听到这些区头都大了,感觉很混乱。下面就结合STM32内核来具体讨论分析这些区到底是什么回事,每种关键字定义的变量又到底是存在...
  • C的内存基本上分为4部分:静态存储区、堆区区以及常量区。他们的功能不同,对他们使用方式也就不同。 在C++中内存分成5个区,分别是堆、、全局/静态存储区、常量存储区和代码区; 内存四区是指:区,堆区...
  • (stack) 存放的都是方法中的局部变量。 方法的运行一定要在当中。 局部变量: 方法中的参数,或者方法{}内部的变量。 作用域: 一旦超出作用域,立刻从内存当中消失。 (heap) 凡是new出来的东西,都在...
  • 之前完全无法理解什么是区、堆区 1、区(stack) 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等,内存的分配是连续的,类似于平时我们所说的,如果还不清楚,那么就把它想成数组,它的内存分配是...
  • 引用类型的全局变量内存分配在上,值类型的全局变量分配在上 局部变量内存分配可能在上也可能在的简单说明: 1.(操作系统):由操作系统自动分配释放 2.(操作系统): 一般由程序员分配释放...
  • 转自:http://blog.csdn.net/hackerain/article/details/7953261http://blog.csdn.net/firefly_2002/article/details/8045096首先要来理解一下可执行文件加载进内存后形成的进程在内存中的结构,如下图:代码:...
  • Java 里的分为 虚拟机与本地方法,在大家口中经常说的,一般是指我们的虚拟机 虚拟机 Java 虚拟机(后面简称)是线程私有的,所以他的生命周期与当前线程是一样的,是用来描述方法执行的一个内存...
  • C语言程序中的、静态存储

    千次阅读 2018-10-17 15:54:47
    是现代计算机程序里最为重要的概念之一 ...为什么有了还需要? *上的数据在函数返回后就会被释放掉,无法传递到函数外部,如:局部数组 是程序中一块巨大的内存空间,可由程序自由使用 中被程序...
  • 与堆、区与堆区----两者的区别

    千次阅读 2018-06-13 08:39:38
     2、内存模型里面的区和堆区和数据结构没有关系,底层也不是讲用了数据结构里面的堆栈的存储方式。但是类似,区(stack) 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构...
  • C#中是编译期间就分配好的内存空间,因此你的代码中必须就的大小有明确的定义;是程序运行期间动态分配的内存空间,你可以根据程序的运行情况确定要分配的内存的大小
  • 文章主要介绍了的区别联系
  • ,方法之间的引用关系

    千次阅读 2018-02-28 19:21:57
    序言在jvm的内存模型中主要包括包括 虚拟机,方法,pc计数器,native。1. 这里说的是java,请和本地方法栈区分开。是一种先入后出的数据结构,java在java.util 包下就有实现了的stack,她在jdk...
  • C++_静态存储__的区别
  • 堆区:存放的是使用new关键字创建的类或者数组的(含成员变量); 区:存放的是局部变量(注:形参也是局部变量的一种)和对象的声明引用; 方法区(常量池):存放的是字符串常量,其他基本数据类型的常量,...
  • 变量的存储位置堆区区分析

    千次阅读 2019-06-16 20:03:15
    什么是区,什么是堆区三. 变量存放的位置四. 举例五. 区和堆区的关系六. 总结 一. 什么是,什么是堆 (stack): 是一种先进后出的数据结构,在中被删除的总是最近被插入的元素和队列刚好相反。 堆(heap)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 406,985
精华内容 162,794
关键字:

栈区、堆区