一: 基本概念:
1.内存分配方式
内存分配方式有三种:
[1]从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static变量。
[2]在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。
[3]从堆上分配,亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存,程序员自己负责在何时用free或delete释放内存。动态内存的生存期由程序员决定,使用非常灵活,但如果在堆上分配了空间,就有责任回收它,否则运行的程序会出现内存泄漏,频繁地分配和释放不同大小的堆空间将会产生堆内碎块。
2.程序的内存空间
一个程序将操作系统分配给其运行的内存块分为4个区域,如下图所示。
代码区(code area) | 程序内存空间 |
全局数据区(data area) | |
堆区(heap area) | |
栈区(stack area) |
一个由C/C++编译的程序占用的内存分为以下几个部分,
1、栈区(stack) 由编译器自动分配释放 ,存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。其操作方式类似于数据结构中的栈。
2、堆区(heap) 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。分配方式类似于链表。
3、全局区(静态区)(static)存放全局变量、静态数据、常量。程序结束后有系统释放
4、文字常量区常量字符串就是放在这里的。 程序结束后由系统释放。
5、程序代码区存放函数体(类成员函数和全局函数)的二进制代码。
下面给出例子程序,
int a = 0; //全局初始化区 char *p1; //全局未初始化区 int main() { int b; //栈 char s[] = \"abc\"; //栈 char *p2; //栈 char *p3 = \"123456\"; //123456\\0在常量区,p3在栈上。 static int c =0;//全局(静态)初始化区 p1 = new char[10]; p2 = new char[20]; //分配得来得和字节的区域就在堆区。 strcpy(p1, \"123456\"); //123456\\0放在常量区,编译器可能会将它与p3所指向的\"123456\"优化成一个地方。 } |
3.堆与栈的比较
3.1申请方式
stack: 由系统自动分配。例如,声明在函数中一个局部变量 int b;系统自动在栈中为b开辟空间。
heap: 需要程序员自己申请,并指明大小,在C中malloc函数,C++中是new运算符。
如p1 = (char *)malloc(10); p1 =new char[10];
如p2 = (char*)malloc(10); p2 = new char[20];
但是注意p1、p2本身是在栈中的。
3.2申请后系统的响应
栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。
堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序。
对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的delete语句才能正确的释放本内存空间。
由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。
3.3申请大小的限制
栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在 WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因 此,能从栈获得的空间较小。
堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。
3.4申请效率的比较
栈由系统自动分配,速度较快。但程序员是无法控制的。
堆是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便。
另外,在WINDOWS下,最好的方式是用VirtualAlloc分配内存,他不是在堆,也不是栈,而是直接在进程的地址空间中保留一快内存,虽然用起来最不方便。但是速度快,也最灵活。
栈:在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行。
堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。
3.6存取效率的比较
char s1[] = \"a\";
char *s2 = \"b\";
a是在运行时刻赋值的;而b是在编译时就确定的;但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。 比如:
int main(){ char a = 1; char c[] = \"1234567890\"; char *p =\"1234567890\"; a = c[1]; a = p[1]; return 0; } |
对应的汇编代码
10: a = c[1]; |
第一种在读取时直接就把字符串中的元素读到寄存器cl中,而第二种则要先把指针值读到edx中,再根据edx读取字符,显然慢了。
3.7小结
堆和栈的主要区别由以下几点:
1、管理方式不同;
2、空间大小不同;
3、能否产生碎片不同;
4、生长方向不同;
5、分配方式不同;
6、分配效率不同;
管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生memory leak。
空间大小:一般来讲在32位系统下,堆内存可以达到4G的空间,从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲,一般都是有一定的空间大小的,例如,在VC6下面,默认的栈空间大小是1M。当然,这个值可以修改。
碎片问题:对于堆来讲,频繁的new/delete势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。对于栈来讲,则不会存在这个问题,因为栈是先进后出的队列,他们是如此的一一对应,以至于永远都不可能有一个内存块从栈中间弹出,在他弹出之前,在他上面的后进的栈内容已经被弹出,详细的可以参考数据结构。
生长方向:对于堆来讲,生长方向是向上的,也就是向着内存地址增加的方向;对于栈来讲,它的生长方向是向下的,是向着内存地址减小的方向增长。
分配方式:堆都是动态分配的,没有静态分配的堆。栈有2种分配方式:静态分配和动态分配。静态分配是编译器完成的,比如局部变量的分配。动态分配由malloca函数进行分配,但是栈的动态分配和堆是不同的,他的动态分配是由编译器进行释放,无需我们手工实现。
分配效率:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。堆则是C/C++函数库提供的,它的机制是很复杂的,例如为了分配一块内存,库函数会按照一定的算法(具体的算法可以参考数据结构/操作系统)在堆内存中搜索可用的足够大小的空间,如果没有足够大小的空间(可能是由于内存碎片太多),就有可能调用系统功能去增加程序数据段的内存空间,这样就有机会分 到足够大小的内存,然后进行返回。显然,堆的效率比栈要低得多。
从这里我们可以看到,堆和栈相比,由于大量new/delete的使用,容易造成大量的内存碎片;由于没有专门的系统支持,效率很低;由于可能引发用户态和核心态的切换,内存的申请,代价变得更加昂贵。所以栈在程序中是应用最广泛的,就算是函数的调用也利用栈去完成,函数调用过程中的参数,返回地址, EBP和局部变量都采用栈的方式存放。所以,我们推荐大家尽量用栈,而不是用堆。
虽然栈有如此众多的好处,但是由于和堆相比不是那么灵活,有时候分配大量的内存空间,还是用堆好一些。
无论是堆还是栈,都要防止越界现象的发生(除非你是故意使其越界),因为越界的结果要么是程序崩溃,要么是摧毁程序的堆、栈结构,产生以想不到的结果。
4.new/delete与malloc/free比较
从C++角度上说,使用new分配堆空间可以调用类的构造函数,而malloc()函数仅仅是一个函数调用,它不会调用构造函数,它所接受的参数是一个unsigned long类型。同样,delete在释放堆空间之前会调用析构函数,而free函数则不会。
class Time{ public: Time(int,int,int,string); ~Time(){ cout<<\"call Time\'s destructor by:\"<<name<<endl; } private: int hour; int min; int sec; string name; }; Time::Time(int h,int m,int s,string n){ hour=h; min=m; sec=s; name=n; cout<<\"call Time\'s constructor by:\"<<name<<endl; } int main(){ Time *t1; t1=(Time*)malloc(sizeof(Time)); free(t1); Time *t2; t2=new Time(0,0,0,\"t2\"); delete t2; system(\"PAUSE\"); return EXIT_SUCCESS; } |
结果:
call Time\'s constructor by:t2
call Time\'s destructor by:t2
从结果可以看出,使用new/delete可以调用对象的构造函数与析构函数,并且示例中调用的是一个非默认构造函数。但在堆上分配对象数组时,只能调用默认构造函数,不能调用其他任何构造函数。
C++中关于new和delete的使用
最近一直在啃C++ Primer中文版第4版,发现 C++中new和delete应用遍布全书,现对其使用作简单总结。在C++中,可以使用new和delete动态创建和释放数组或者单个对象,现在对它们的使用一一道来。
1.创建动态数组
数组类型的变量有三个重要的限制:数组长度固定不变,在编译时必须知道它的长度,数组只在定义它的块语句中存在。对于动态分配的数组,虽然长度是固定的,但是动态分配的数组不必在编译时知道其长度,可以(通常也是)在运行时才确定数组长度;同时,动态分配的数组一直存在直到程序显示释放为止,这样,我们就可以自己决定数组的存在与否了。
每个程序在执行时都占用一块可用的内存空间,用于存放动态分配的对象,此内存空间称为程序的自由存储区(freestore)或堆(heap).C++语言使用new和delete在自由存储区中分配存储空间。
动态分配数组时,只需指定类型和数组长度,不必为数组对象命名,new表达式返回指向新分配数组的第一个元素的指针:
int *pia=new int[10];
此new表达式分配了一个含有10个int型元素的数组,并返回指向该数组第一个元素的指针。在自由存储区创建的数组对象是没有名字的,程序员只能通过其地址间接地访问堆中的对象。
动态分配数组时,如果数组元素具有类类型,将使用该类的默认构造函数实现初始化;如果数组元素是内置类型,则无初始化:
string *psa = new string[10];// 调用string类的默认构造函数依次初始化数组中的每个元素,同时分配存储空间。
int *pis = new int[10]; //无初始化值
可使用跟在数组长度后面的一对空圆括号,对数组元素作值初始化:
int *pis = new int[10](); //数组元素都设置为0
之所以要动态分配数组,往往是由于编译时并不知道数组的长度。C++中允许动态分配空数组:
size_t n = get_size();
int *p = new int[n];
for(int *q=p;q!=p+n;++q)
『/*处理数组元素的相关代码*/』
在上面的例子中,只有在程序运行时才能确定n的值。如果n的值为0,代码依然正确执行。C++中虽然不允许定义长度为0的数组变量,但是明确指出,调用new动态创建长度为0的数组是合法的。
char *cp = new char[10];
用new动态创建长度为0的数组时,new返回有效的非零指针,但不能进行解引用,因为它毕竟没有指向任何元素。
2. 动态创建单个对象
动态创建对象时,只需指定其数据类型,不必为该对象命名,new表达式返回指向新创建对象的指针,我们通过该指针来访问此对象:
int *pi = new int(1024);
string *ps = new string(10, '9');
在C++中使用直接初始化语法规则初始化动态创建的对象,上面的表达式就使用该语法规则初始化了动态创建的对象。对于类类型的对象,则使用该类类型的构造函数初始化对象。可对动态创建的对象做值初始化,如下所示:
string *ps = new string();
int *pi = new int();
对于提供了默认构造函数的类类型,没有必要进行值初始化。如果没有显示初始化动态创建的对象,则对于类类型的对象,用该类的默认构造函数初始化,对于内置类型的对象则无初始化。
3. 动态空间的释放
动态分配的内存最后必须进行释放。如果不需要动态创建的数组,我们必须显示地将其占用的存储空间返还给程序的自由存储区。C++中使用delete [ ]表达式释放指针所指向的数组空间:
delete [ ] pis;
该语句释放上面所创建的动态int型数组所占有的存储空间。在关键字delete和指针之间的[ ]告诉编译器该指针指向的是自由存储区中的数组,而并非单个对象。对于表达式
delete pi;
该命令释放了pi指向的int型对象所占用的内存空间。删除指针后,该指针变成悬垂指针(danglingpointer).悬垂指针指向曾今存放对象的内存但该对象已经不存在了。悬垂指针往往导致程序错误,而且很难检测出来。一旦删除了指针所指向的对象,立即将指针置为0,这样就非常清楚地表明指针不再指向任何对象。
数组的动态分配(new)、初始化(memset)和撤销(delete)
一维数组的动态分配,初始化和撤销都好说,几乎每一本C++教材都会做出详细的说明。具体如下:
动态分配(例如分配10个单元的): int *array=new int [10];
初始化:memset(array,0,sizeof(array)); (也可以利用一个for循环对其赋值初始化)
撤销:delete [] array;
下面来说二维数组的。
二维数组(n行m列)利用new来进行动态分配实际上相当于对n个m元数组进行动态分配,只不过我们不能一味的按照动态分配一维数组的方法来进行这项操作。MSVC目前还没有这般的人性化,具体应该这样做:
int **array;
array=new int *[10];
for(int i=0;i<10;i++)
array[i]=new int [5];
上面的操作完成了一个10行5列的二维数组array[10][5]的动态分配,可以看到我们先动态分配了一个10单元的数组的指针的指针的首地址给**array,然后再对其每个首地址进行遍历,同时完成一个5单元的数组的动态分分配,并把首地址给*array[i],从而最终完成了二维数组array[10][5]的动态分配。我们可以依此类推得到三维以至多维的数组的动态分配方法。
二维数组的初始化:如果把一维数组初始化办法照搬过来就会发现对于动态分配的二维数组并不适用。这就要理解到memset这个函数三个参数的含义。MSDNhttp://blog.csdn.net/shanzhizi对memset的描述如下:
memset
Sets buffers to a specified character.
void *memset( void *dest, int c, size_t count );
可见memset只能作用于一个一维数组void *dest,因此最好的办法就是和二维数组的动态分配结合起来,new一个,memset一个。
我的理解是memset只作用于一块连续的内存空间,而动态开辟的空间不一定是连续的,SO。
具体写法如下:
int **array;
array=new int *[10];
for(int i=0;i<10;i++)
{
array[i]=new int [5];
memset(array,0,5*sizeof(int));
}
可以看到这里的memset的第三个参数有了变化。
二维数组的撤销:
for (int i = 0; i < 10; i ++) {
delete[] array[i];
}
delete [] array;
三维数组用一个例子说明:
#include <stdio.h>
#include <memory.h>
#define size1 5
#define size2 10
#define size3 15
int main()
{
int *** arr;
int i,j,k;
/// 动态开辟 相当于arr[size1][size2][size3]
arr = new int**[size1];
for (i = 0; i < size1; i ++) {
arr[i] = new int*[size2];
for (j = 0; j < size2; j ++) {
arr[i][j] = new int[size3];
}
}
/// 用for循环初始化
for (i = 0; i < size1; i ++) {
for (j = 0; j < size2; j ++) {
for (k = 0; k < size3; k ++) {
arr[i][j][k] = i * j * k;
}
}
}
for (i = 0; i < size1; i ++) {
for (j = 0; j < size2; j ++) {
for (k = 0; k < size3; k ++) {
printf("i*j*k=%d*%d*%d=%d/n",i,j,k,arr[i][j][k]);
}
}
}
/// 用memset,如果是静态int arr[][][]的话,直接memset(arr,0,sizeof(arr));数组初始化为0
for (i = 0; i < size1; i ++) {
for (j = 0; j < size2; j ++) {
memset(arr[i][j],-1,sizeof(int) * size3);
}
}
for (i = 0; i < size1; i ++) {
for (j = 0; j < size2; j ++) {
for (k = 0; k < size3; k ++) {
printf("i,j,k=%d,%d,%d=%d/n",i,j,k,arr[i][j][k]);
}
}
}
/ 释放内存
for (i = 0; i < size1; i ++) {
for (j = 0; j < size2; j ++) {
delete[] arr[i][j];
}
delete[] arr[i];
}
delete[] arr;
return 0;
}