您的位置:首页 > 理论基础

计算机内存分配

2015-03-03 23:33 288 查看

从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static变量。

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

从堆上分配,亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存,程序员自己负责在何时用free或delete释放内存。动态内存的生存期由程序员决定,使用非常灵活,但如果在堆上分配了空间,就有责任回收它,否则运行的程序会出现内存泄漏,频繁地分配和释放不同大小的堆空间将会产生堆内碎块。

程序的内存空间:

一个程序将操作系统分配给其运行的内存块分为5个区域,如下图所示。

栈区(stack area)
程序内存空间
堆区(heap area)
全局数据区(data area)
文字常量区
代码区(code area)
一个由C/C++编译的程序占用的内存分为以下几个部分,

栈区(stack)


由编译器自动分配释放,一般使用寄存器来存取,效率很高,但是分配的内存容量有限。一般暂时存放为运行函数而分配的局部变量,函数参数,返回数据,返回地址等。操作方式类似数据结构中的栈。

堆区(heap)

亦称动态内存。如malloc和new申请的内存空间。动态内存的生存期一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收。分配方式类似于链表。

全局区(static)

从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。存放全局变量、静态数据、常量。程序结束后由系统释放

文字常量区

常量字符串就是放在这里的, 程序结束后由系统释放。

程序代码区

存放函数体(类成员函数和全局函数)的二进制代码。因为存储是数据和代码分开存储的

下面给出例子程序,

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); //p1,p2本身在栈中

p2 = (char *)malloc(20); //分配得来的10和20字节的区域就在堆区。

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

}

堆与栈的比较:

1) 申请方式

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

2) 申请后系统的响应

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

3) 申请大小的限制

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

4) 申请效率的比较

:由系统自动分配,速度较快。但程序员是无法控制的。
:是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便。

5) 堆和栈中的存储内容

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

6) 小结

堆和栈的主要区别由以下几点:

管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生memory leak。memory leak:内存泄漏,用动态存储分配函数动态开辟的空间,在使用完毕后未释放,结果导致一直占据该内存单元。直到程序结束。

空间大小:一般来讲在32位系统下,堆内存可以达到4G的空间,从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲,一般都是有一定的空间大小的,例如,在VC6下面,默认的栈空间大小是1M。当然,这个值可以修改。分配大量的内存空间,用堆比较灵活。

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

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

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

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

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

无论是堆还是栈,都要防止越界现象的发生(除非你是故意使其越界),因为越界的结果要么是程序崩溃,要么是摧毁程序的堆、栈结构,产生以想不到的结果。

new/delete与malloc/free详解

malloc与free是C++/C语言的标准库函数,new/delete是C++的运算符。它们都可用于申请和释放动态内存(堆)。

C语言的函数malloc和free:

1) 函数malloc和free在头文件<stdlib.h>中的原型及参数

void * malloc(size_t size);

动态配置内存,大小有size决定,返回值成功时为任意类型指针,失败时为NULL。

void free(void *ptr);

释放动态申请的内存空间,调用free()后ptr所指向的内存空间被收回,如果ptr指向未知地方或者指向的空间已被收回,则会发生不可预知的错误,如果ptr为NULL,free不会有任何作用。

2) C语言中典型用法

T为任意数据类型

T * p = (T *) malloc (sizeof (T) * n)

if (NULL= =p)

{

printf (“malloc fail!\n”);

……//相关资源收回的处理

exit (-1);

}

… …//此过程不能改变指针p的指向

free (p);

注意:malloc后通常要对返回值进行判断,避免发生不必要的错误。

3) 内存说明

malloc函数动态申请的内存空间是在堆里(而一般局部变量存于栈里),并且该段内存不会被初始化,与全局变量不一样,如果不采用手动free()加以释放,则该段内存一直存在,直到程序退出才被系统,所以为了合理使用内存,在不适用该段内存时,应该调用free()。另外,如果在一个函数里面使用过malloc,最好要配对使用free,否则容易造成内存泄露。

4) 不足

对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free。

C++中的运算符new和delete:

new和delete是C++中的运算符,不是库函数,不需要库的支持,同时,他们是封装好的重载运算符,并且可以再次进行重载。

1) 运算符new和delete

new是动态分配内存的运算符,自动计算需要分配的空间,在C++中,它属于重载运算符,可以对多种数据类型形式进行分配内存空间,比如int型、char型、结构体型和类等的动态申请的内存分配,分配类的内存空间时,同时调用类的构造函数,对内存空间进行初始化,即完成类的初始化工作。

delete是撤销动态申请的内存运算符。delete与new通常配对使用,与new的功能相反,可以对多种数据类型形式的内存进行撤销,包括类,撤销类的内存空间时,它要调用其析构函数,完成相应的清理工作,收回相应的内存资源。

2) 典型用法

int *p = new int;
delete p;
char *p = new char;delete p;
类的类型 *p = new 类的类型;delete p;

//注意,指针p存于栈中,p所指向的内存空间却是在堆中。

Obj * p = new Obj[100];delete [ ]p;

//注意,new申请数组,delete删除的形式需要加括号“[ ]”,表示对数组空间的操作,总之,申请形式如何,释放的形式就如何。

3) 内存说明

new申请的内存也是存于堆中,所以在不需要使用时,需要delete手动收回。

4) 动态内存的管理

删除( delete )指向动态分配内存的指针失败,因而无法将该块内存返还给自由存储区。删除动态分配内存失败称为“内存泄漏(memory leak)”。内存泄漏很难发现,一般需等应用程序运行了一段时间后,耗尽了所有内存空间时,内存泄漏才会显露出来。

读写已删除的对象。如果删除指针所指向的对象之后,将指针置为0值,则比较容易检测出这类错误。

对同一个内存空间使用两次 delete 表达式。当两个指针指向同一个动态创建的对象,删除时就会发生错误。如果在其中一个指针上做 delete 运算,将该对象的内存空间返还给自由存储区,然后接着 delete 第二个指针, 此时则自由存储区可能会被破坏。

操纵动态分配的内存时,很容易发生上述错误,但这些错误却难以跟踪和修正。

new/delete与malloc/free之间的联系和区别:

1) malloc/free和new/delete的联系

存储方式相同。malloc和new动态申请的内存都位于堆中。申请的内存都不能自动被操作系统收回,都需要配套的free和delete来释放。
除了带有构造函数和析构函数的类等数据类型以外,对于一般数据类型,如int、char等等,两组动态申请的方式可以通用,作用效果一样,只是形式不一样。
内存泄漏对于malloc或者new都可以检查出来的,区别在于new可以指明是那个文件的那一行,而malloc没有这些信息。
两组都需要配对使用,malloc配free,new配delete,注意,这不仅仅是习惯问题,如果不配对使用,容易造成内存泄露。同时,在C++中,两组之间不能混着用,虽说有时能编译过,但容易存在较大的隐患。
C++程序经常要调用C函数,而C程序只能用malloc/free管理动态内存

2) malloc/free和new/delete的区别

malloc和free返回void类型指针,new和delete直接带具体类型的指针。new可以认为是malloc加构造函数的执行。
malloc和free属于C语言中的函数,需要库的支持,而new/delete是C++中的运算符,况且可以重载,所以new/delete的执行效率高些。C++中为了兼用C语法,所以保留malloc和free的使用,但建议尽量使用new和delete。

在C++中,new是类型安全的,而malloc不是。例如:

int* p = new char[10]; // 编译时指出错误

delete [ ]p; //对数组需要加中括号“[ ]”

int* p = malloc(sizeof(char )*10); // 编译时无法指出错误

free (p); //只需要所释放内存的头指针

使用new动态申请类对象的内存空间时,类对象的构建要调用构造函数,相当于对内存空间进行了初始化。而malloc动态申请的类对象的内存空间时,不会初始化,也就是说申请的内存空间无法使用,因为类的初始化是由构造函数完成的。delete和free的意义分别于new和malloc相反,delete在释放堆空间之前会调用析构函数,而free函数则不会。

不能用malloc和free来完成类对象的动态创建和删除。
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: