内存区划分、内存分配、常量存储区、堆、栈、自由存储区、全局区[C ][内存管理]
内存区划分、内存分配、常量存储区、堆、栈、自由存储区、全局区[C++][内存管理]一.在c中分为这几个存储区1.栈- 由编译器自动分配释放2.堆- 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收3.全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
- 程序结束释放4.另外还有一个专门放常量的地方。
- 程序结束释放#define不占用内存单元。
C++编译器通常并不给const常量分配存储空间，而是把const变量的定义保存在符号表里。
在VC中，const变量与一般变量一样，都分配内存空间。
在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。
在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static 表示只在该函数体内有效。
另外，函数中的"adgfdf"这样的字符串存放在常量区。
比如：int a = 0; //全局初始化区char *p1; //全局未初始化区void main(){int b; //栈char s[] = "abc"; //栈char *p2; //栈char *p3 = "123456"; //123456{post.content}在常量区，p3在栈上static int c = 0; //全局（静态）初始化区p1 = (char *)malloc(10); //分配得来得10字节的区域在堆区p2 = (char *)malloc(20); //分配得来得20字节的区域在堆区strcpy(p1, "123456");//123456{post.content}放在常量区，编译器可能会将它与p3所指向的"123456"优化成一块}二.在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区1.栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。
里面的变量通常是局部变量、函数参数等。
2.堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
3.自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
4.全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
5.常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改）三. 谈谈堆与栈的关系与区别具体地说，现代计算机(串行执行机制)，都直接在代码底层支持栈的数据结构。
这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。
这种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。
因为栈的这种特点，对栈的使用在程序中是非常频繁的。
对子程序的调用就是直接利用栈完成的。
机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。
C/C++中的自动变量是直接利用栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因。
和栈不同，堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的，而是由函数库提供的。
基本的malloc/realloc/free 函数维护了一套内部的堆数据结构。
当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。
当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。
这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)，使用这套机制有如下若干原因：1. 系统调用可能不支持任意大小的内存分配。
有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。
2. 系统调用申请内存可能是代价昂贵的。
系统调用可能涉及用户态和核心态的转换。
3. 没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。
堆和栈的对比从以上知识可知，栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。
栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。
不同堆分配的内存无法互相操作。
栈空间分静态分配和动态分配两种。
静态分配是编译器完成的，比如自动变量(auto)的分配。
动态分配由alloca函数完成。
栈的动态分配无需释放(是自动的)，也就没有释放函数。
为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/ 释放内存匹配是良好程序的基本要素。
1.碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。
对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以>参考数据结构，这里我们就不再一一讨论了。
2.生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
3.分配方式：堆都是动态分配的，没有静态分配的堆。
栈有2种分配方式：静态分配和动态分配。
静态分配是编译器完成的，比如局部变量的分配。
动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
4.分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。
堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。
显然，堆的效率比栈要低得多。
明确区分堆与栈:在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
首先，我们举一个例子：void f(){int* p=new int[5];}这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。
在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：00401028 push 14h0040102A call operator new (00401060)0040102F add esp,400401032 mov dword ptr [ebp-8],eax00401035 mov eax,dword ptr [ebp-8]00401038 mov dword ptr [ebp-4],eax这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。
好了，我们回到我们的主题：堆和栈究竟有什么区别？主要的区别由以下几点：1、管理方式不同；2、空间大小不同；3、能否产生碎片不同；4、生长方向不同；5、分配方式不同；6、分配效率不同；管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。
但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。
当然，我们可以修改：打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。
所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。
所以，我们推荐大家尽量用栈，而不是用堆。
另外对存取效率的比较:代码:char s1[] = "aaaaaaaaaaaaaaa";char *s2 = "bbbbbbbbbbbbbbbbb";aaaaaaaaaaa是在运行时刻赋值的；而bbbbbbbbbbb是在编译时就确定的；但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：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],cl11: 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读取字符，显然慢了.无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉,编写稳定安全的代码才是最重要的。
C C++语言变量声明内存分配
C/C++语言变量声明内存分配2010-11-08 07:10:20| 分类：编程|字号订阅一个由c/C++编译的程序占用的内存分为以下几个部分1、栈区（stack）—程序运行时由编译器自动分配，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
程序结束时由编译器自动释放。
2、堆区（heap）—在内存开辟另一块存储区域。
一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—编译器编译时即分配内存。
全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
- 程序结束后由系统释放4、文字常量区—常量字符串就是放在这里的。
程序结束后由系统释放5、程序代码区—存放函数体的二进制代码。
例子程序这是一个前辈写的，非常详细//main.cppint 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);p2 = (char *)malloc(20);//分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); //123456/0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}===============C语言程序的内存分配方式1.内存分配方式内存分配方式有三种：[1]从静态存储区域分配。
c++内存分配机制
C++的内存分配机制可以分为四个区域：堆区、栈区、全局/静态存储区和常量存储区。
1. 堆区：动态内存分配区，程序在运行时可以向该区域申请一定大小的内存，用malloc或new来申请，用free或delete来释放。
2. 栈区：存放函数的参数值和局部变量，由编译器自动分配和释放，其操作方式类似于数据结构中的栈。
3. 全局/静态存储区：全局变量和静态变量被存放在此区域中，包括初始化的全局变量和静态变量（空白初始化的全局变量和静态变量也会被存放在此区域），全局变量和静态变量在程序整个运行期间一直被保留。
4. 常量存储区：常量被存放在此区域中，不允许修改。
C++内存分配机制遵循二八定律，即80%的内存空间被80%的程序所使用，而剩下的20%的内存空间则被浪费。
因此，在编写C++程序时，应该尽可能地利用好内存空间，避免内存空间的浪费。
单片机C语言 必知的数据存储与程序编写知识 附单片机应用编程知识介绍
一、五大内存分区内存分成5个区，它们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
1、栈区（StaCk）：FIFo就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。
里面的变量通常是局部变量、函数参数等。
2、堆区（heap）：就是那些由new分配的内存块，它们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
3、自由存储区：就是那些由malloc等分配的内存块，它和堆是十分相似的，不过它是用free 来结束自己的生命。
4、全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
5、常量存储区：这是一块比较特殊的存储区，它们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）code/data/stack内存主要分为代码段，数据段和堆栈。
代码段放程序代码，属于只读内存。
数据段存放全局变量，静态变量，常量等，堆里存放自己malloc或new出来的变量，其他变量就存放在栈里，堆栈之间空间是有浮动的。
数据段的内存会到程序执行完才释放。
调用函数先找到函数的入口地址，然后计算给函数的形参和临时变量在栈里分配空间，拷贝实参的副本传给形参，然后进行压栈操作，函数执行完再进行弹栈操作。
字符常量一般放在数据段，而且相同的字符常量只会存一份。
二、C语言程序的存储区域1、由C语言代码（文本文件）形成可执行程序（二进制文件），需要经过编译-汇编-连接三个阶段。
编译过程把C语言文本文件生成汇编程序，汇编过程把汇编程序形成二进制机器代码，连接过程则将各个源文件生成的二进制机器代码文件组合成一个文件。
2、C语言编写的程序经过编译-连接后，将形成一个统一文件，它由几个部分组成。
堆栈及静态数据区详解
堆、栈及静态数据区详解五大内存分区在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。
里面的变量通常是局部变量、函数参数等。
堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free 来结束自己的生命的。
全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）明确区分堆与栈在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
首先，我们举一个例子：void f() { int* p=new int[5]; }这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。
在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：00401028 push 14h0040102A call operator new (00401060)0040102F add esp,400401032 mov dword ptr [ebp-8],eax00401035 mov eax,dword ptr [ebp-8]00401038 mov dword ptr [ebp-4],eax这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie 信息去进行释放内存的工作。
内存泄漏和内存溢出、堆内存和栈内存区分、负载标准、降低cache内存方法
（一）内存泄漏和内存溢出内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。
内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。
内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。
memory leak会最终会导致out of memory。
（二）堆内存和栈内存区分一、数据结构中的堆和栈1. 栈是一种连续储存的数据结构，具有先进后出的性质。
通常的操作有入栈（压栈），出栈和栈顶元素。
想要读取栈中的某个元素，就是将其之间的所有元素出栈才能完成。
2. 堆是一种非连续的树形储存数据结构，每个节点有一个值，整棵树是经过排序的。
特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。
常用来实现优先队列，存取随意。
二、内存中的栈区与堆区1. 内存中的栈区与堆区比较2. 计算机内存的大致划分一般说到内存，指的是计算机的随机存储器（RAM），程序都是在这里面运行。
三、栈内存与栈溢出由程序自动向操作系统申请分配以及回收，速度快，使用方便，但程序员无法控制。
若分配失败，则提示栈溢出错误。
注意，const 局部变量也储存在栈区内，栈区向地址减小的方向增长。
四、堆内存与内存泄露程序员向操作系统申请一块内存，当系统收到程序的申请时，会遍历一个记录空闲内存地址的链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。
内存分配方式范文
内存分配方式范文内存分配是计算机中的重要概念，它指的是将计算机的内存资源分配给不同的程序和数据。
内存分配方式可以根据分配的策略和实现方式来进行分类。
下面将介绍几种常见的内存分配方式。
1.静态分配：静态分配是指在编译或链接阶段将内存空间分配给程序的变量或数据结构。
在静态分配中，内存的分配和释放是由编译器或链接器完成的，程序在运行期间不会改变内存分配的情况。
静态分配的优点是分配速度快，不会发生内存碎片问题，但缺点是需要预先确定内存的大小，不能动态调整。
2.动态分配：动态分配是在程序运行期间根据需要分配和释放内存空间。
常见的动态分配方式有以下几种：- 堆（Heap）分配：堆分配是通过指定大小在堆内存中分配一块连续的内存空间。
它通常用于创建动态分配的数据结构，如链表、树、堆等。
堆分配的优点是可以根据需要分配灵活大小的内存，但缺点是分配和释放的速度较慢，并且容易产生内存碎片。
- 栈（Stack）分配：栈分配是指在程序运行期间分配局部变量和函数调用的内存空间。
栈内存具有后进先出的特性，每次分配内存只需要修改栈指针即可。
栈分配的优点是分配和释放速度快，但缺点是分配的内存大小固定，不适合动态分配。
- 池（Pool）分配：池分配是指事先在内存中创建一定数量的内存块，然后根据需要从池中分配和释放内存。
池分配的优点是分配和释放速度快，且不容易产生内存碎片，但缺点是需要事先确定池的大小，不能动态调整。
3.分区分配：分区分配是指将内存空间分成多个固定大小的分区，每个分区用于分配给不同的程序或数据。
常见的分区分配方式有以下几种：-等大小分区：等大小分区是将内存空间分成大小相等的分区，每个分区只能分配给一个程序或数据。
这种分区方式容易产生内存碎片，但分配和释放速度较快。
-不等大小分区：不等大小分区是将内存空间分成大小不等的分区，每个分区可以根据需要分配给不同大小的程序或数据。
这种分区方式可以更有效地利用内存空间，但分配和释放速度较慢。
内存中堆栈的划分
栈和堆的区别 (转) 终于知道区别了(2007-09-12 08:50:49)转载标签：IT/科技一个由 c/C++ 编译的程序占用的内存分为以下几个部分：1 、栈区（ stack ）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
2 、堆区（ heap ）—一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3 、全局区（静态区）（ static ）—全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
程序结束后由有系统释放。
4 、文字常量区—常量字符串就是放在这里的。
程序结束后由系统释放。
5 、程序代码区—存放函数体的二进制代码。
例子程序：这是一个前辈写的，非常详细//main.cppint 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"优化成一个地方。
}栈：在 Windows 下，栈是向低地址扩展的数据结构，是一块连续的内存的区域。
这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS 下，栈的大小是 2M （也有的说是 1M ，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示 overflow 。
C语言内存分配问题(整理)
我查了下资料，有说分四个，有说分五个加一个程序代码区，我没查到参考的专业书籍。所 以麻烦知道的告知一下，完善一下。
2、 内存分配方式 内存分配方式有三种：
1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整 个运行期间都存在。例如全局变量，static 变量。
4、动态分配释放内存举例 用 malloc 动态分配内存后一定要判断一下分配是否成功，判断指针的值是否为 NULL。 内存分配成功后要对内存单元进行初始化。 内存分配成功且初始化后使用时别越界了。 内存使用完后要用 free（p）释放，注意，释放后，p 的值是不会变的，仍然是一个地址值， 仍然指向那块内存区，只是这块内存区的值变成垃圾了。为了防止后面继续使用这块内存， 应在 free(p)后，立即 p=NULL，这样后面如果要使用，判断 p 是否为 NULL 时就会判断出 来。
NO.2
char *GetMemory(void) {
char Байду номын сангаас[] = hello world; retrun p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); }
问题同 NO.1
NO.3
void GetMemory(char **p, int num) {
free(str); if(str != NULL) {
strcpy(str,"world"); printf(str); } }
问题同 NO.1 我对以上问题的分析：
NO.1：程序首先申请一个 char 类型的指针 str,并把 str 指向 NULL（即 str 里存的是 NULL 的地址，*str 为 NULL 中的值为０），调用函数的过程中做了如下动作： 1、申请一个 char 类型的指针 p， 2、把 str 的内容 copy 到了 p 里（这是参数传递过程中系统所做的）, 3、为 p 指针申请了 100 个空间， 4、返回 Test 函数．最后程序把字符串 hello world 拷贝到 str 指向的内存空间里．到这里错 误出现了！ str 的空间始终为 NULL 而并没有实际的空间．深刻理解函数调用的第 2 步，将不难发现问 题所在！（注意：传递的参数和消除的参数） NO.2：程序首先申请一个 char 类型的指针 str,并把 str 指向 NULL．调用函数的过程中做了 如下动作： １申请一数组 p[]并将其赋值为 hello world(数组的空间大小为 12)， ２返回数组名 p 付给 str 指针（即返回了数组的首地址）． 那么这样就可以打印出字符串＂hello world＂了么？当然是不能的！ 因为在函数调用的时候漏掉了最后一步．也就是在第２步 return 数组名后，函数调用还要 进行一步操作，也就是释放内存空间．当一个函数被调用结束后它会释放掉它里面所有的变 量所占用的空间．所以数组空间被释放掉了，也就是说 str 所指向的内容将不确定是什么东 西． NO.3：正确答案为可以打印出 hello．但内存泄漏了！ 需要用 free（）函数进行释放。
内存中的五大区
2.生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
3.分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
00401035 mov eax，dword ptr [ebp-8]
00401038 mov dword ptr [ebp-4]，eax
这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。
4.分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
00401070 8A 42 01 mov al，byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4]，al
1.碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以>参考数据结构，这里我们就不再一一讨论了。
C语言的内存分配详解
堆内存的分配与释放
堆空间申请、释放的方法
在C++中，申请和释放堆中分配的存贮空间， 中 申请和释放堆中分配的存贮空间， 分别使用new和delete的两个运算符来完成： 分别使用 和 的两个运算符来完成： 的两个运算符来完成 指针变量名=new 类型名 初始化式 ； 类型名(初始化式 初始化式)； 指针变量名 delete 指针名 指针名; 例如： 例如：1、 int *pi=new int(0); 它与下列代码序列大体等价： 它与下列代码序列大体等价： 2、int ival=0, *pi=&ival; 区别：pi所指向的变量是由库操作符new()分配的 所指向的变量是由库操作符new()分配的， 区别：pi所指向的变量是由库操作符new()分配的， 位于程序的堆区中，并且该对象未命名 该对象未命名。 位于程序的堆区中，并且该对象未命名。
堆的概念
通常定义变量（或对象），编译器在编译时都可 通常定义变量（或对象），编译器在编译时都可 ）， 以根据该变量（或对象）的类型知道所需内存空间的大小， 以根据该变量（或对象）的类型知道所需内存空间的大小，从 而系统在适当的时候为他们分配确定的存储空间。 而系统在适当的时候为他们分配确定的存储空间。这种内存分 配称为静态存储分配 静态存储分配； 配称为静态存储分配； 有些操作对象只在程序运行时才能确定， 有些操作对象只在程序运行时才能确定，这样编译时就 无法为他们预定存储空间，只能在程序运行时， 无法为他们预定存储空间，只能在程序运行时，系统根据运行 时的要求进行内存分配，这种方法称为动态存储分配 动态存储分配。 时的要求进行内存分配，这种方法称为动态存储分配。所有动 态存储分配都在堆区中进行。 态存储分配都在堆区中进行。 当程序运行到需要一个动态分配的变量或对象时， 当程序运行到需要一个动态分配的变量或对象时，必须 向系统申请取得堆中的一块所需大小的存贮空间， 申请取得堆中的一块所需大小的存贮空间 向系统申请取得堆中的一块所需大小的存贮空间，用于存贮该 变量或对象。当不再使用该变量或对象时， 变量或对象。当不再使用该变量或对象时，也就是它的生命结 束时， 显式释放它所占用的存贮空间 它所占用的存贮空间， 束时，要显式释放它所占用的存贮空间，这样系统就能对该堆 空间进行再次分配，做到重复使用有限的资源。 空间进行再次分配，做到重复使用有限的资源。