[转]浅谈C中的malloc和free
2007-8-20 17:25:46之所以想发表这篇文章，是因为在数据结构学习中需要熟练运用malloc,free,realloc这几个函数，而令我感到不可思议的是——不少同学对这几个函数根本一无所知，连最基本的概念都没有。其实这几个函数就是C中内存管理的主要部分（其实realloc比较少用，原因在下面我将讲到）；还有就是关于比较完整介绍这几个函数的技术文章非常少。这篇文章是我暑假写的，发表出来只希望对大家的学习有点帮助。——前记
在C语言的学习中，对内存管理这部分的知识掌握尤其重要！之前对C中的malloc()和free()两个函数的了解甚少，只知道大概该怎么用——就是malloc然后free就一切OK了。当然现在对这两个函数的体会也不见得多，不过对于本文章第三部分的内容倒是有了转折性的认识，所以写下这篇文章作为一个对知识的总结。这篇文章之所以命名中有个“浅谈”的字眼，也就是这个意思了！希望对大家有一点帮助！
如果不扯得太远的话（比如说操作系统中虚拟内存和物理内存如何运做如何管理之类的知识等），我感觉这篇文章应该是比较全面地谈了一下malloc()和free().这篇文章由浅入深（不见得有多深）分三个部分介绍主要内容。
废话了那么多，下面立刻进入主题：
一、malloc()和free()的基本概念以及基本用法：
1、函数原型及说明：
void *malloc(long NumBytes)：该函数分配了NumBytes个字节，并返回了指向这块内存的指针。如果分配失败，则返回一个空指针（NULL）。
关于分配失败的原因，应该有多种，比如说空间不足就是一种。
void free(void *FirstByte)： 该函数是将之前用malloc分配的空间还给程序或者是操作系统，也就是释放了这块内存，让它重新得到自由。
2、函数的用法：
其实这两个函数用起来倒不是很难，也就是malloc()之后觉得用够了就甩了它把它给free()了，举个简单例子：
// Code...
char *Ptr = NULL;
Ptr = (char *)malloc(100 * sizeof(char));
if (NULL == Ptr)
{
exit (1);
}
gets(Ptr);
// code...
free(Ptr);
Ptr = NULL;
// code...
就是这样！当然，具体情况要具体分析以及具体解决。比如说，你定义了一个指针，在一个函数里申请了一块内存然后通过函数返回传递给这个指针，那么也许释放这块内存这项工作就应该留给其他函数了。
3、关于函数使用需要注意的一些地方：
A、申请了内存空间后，必须检查是否分配成功。
B、当不需要再使用申请的内存时，记得释放；释放后应该把指向这块内存的指针指向NULL，防止程序后面不小心使用了它。
C、这两个函数应该是配对。如果申请后不释放就是内存泄露；如果无故释放那就是什么也没有做。释放只能一次，如果释放两次及两次以上会出现错误（释放空指针例外，释放空指针其实也等于啥也没做，所以释放空指针释放多少次都没有问题）。
D、虽然malloc()函数的类型是(void *),任何类型的指针都可以转换成(void *),但是最好还是在前面进行强制类型转换，因为这样可以躲过一些编译器的检查。
好了！最基础的东西大概这么说！现在进入第二部分：
二、malloc()到底从哪里得来了内存空间：
1、malloc()到底从哪里得到了内存空间？答案是从堆里面获得空间。也就是说函数返回的指针是指向堆里面的一块内存。操作系统中有一个记录空闲内存地址的链表。当操作系统收到程序的申请时，就会遍历该链表，然后就寻找第一个空间大于所申请空间的堆结点，然后就将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。就是这样！
说到这里，不得不另外插入一个小话题，相信大家也知道是什么话题了。什么是堆？说到堆，又忍不住说到了栈！什么是栈？下面就另外开个小部分专门而又简单地说一下这个题外话：
2、什么是堆：堆是大家共有的空间，分全局堆和局部堆。全局堆就是所有没有分配的空间，局部堆就是用户分配的空间。堆在操作系统对进程 初始化的时候分配，运行过程中也可以向系统要额外的堆，但是记得用完了要还给操作系统，要不然就是内存泄漏。
什么是栈：栈是线程独有的，保存其运行状态和局部自动变量的。栈在线程开始的时候初始化，每个线程的栈互相独立。每个函数都有自己的栈，栈被用来在函数之间传递参数。操作系统在切换线程的时候会自动的切换栈，就是切换SS/ESP寄存器。栈空间不需要在高级语言里面显式的分配和释放。
以上的概念描述是标准的描述，不过有个别语句被我删除，不知道因为这样而变得不标准了^_^.
通过上面对概念的描述，可以知道：
栈是由编译器自动分配释放，存放函数的参数值、局部变量的值等。操作方式类似于数据结构中的栈。
堆一般由程序员分配释放，若不释放，程序结束时可能由OS回收。注意这里说是可能，并非一定。所以我想再强调一次，记得要释放！
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。（这点我上面稍微提过）
所以，举个例子，如果你在函数上面定义了一个指针变量，然后在这个函数里申请了一块内存让指针指向它。实际上，这个指针的地址是在栈上，但是它所指向的内容却是在堆上面的！这一点要注意！所以，再想想，在一个函数里申请了空间后，比如说下面这个函数：
// code...
void Function(void)
{
char *p = (char *)malloc(100 * sizeof(char));
}
就这个例子，千万不要认为函数返回，函数所在的栈被销毁指针也跟着销毁，申请的内存也就一样跟着销毁了！这绝对是错误的！因为申请的内存在堆上，而函数所在的栈被销毁跟堆完全没有啥关系。所以，还是那句话：记得释放！
3、free()到底释放了什么
这个问题比较简单，其实我是想和第二大部分的题目相呼应而已！哈哈！free()释放的是指针指向的内存！注意！释放的是内存，不是指针！这点非常非常重要！指针是一个变量，只有程序结束时才被销毁。释放了内存空间后，原来指向这块空间的指针还是存在！只不过现在指针指向的内容的垃圾，是未定义的，所以说是垃圾。因此，前面我已经说过了，释放内存后把指针指向NULL，防止指针在后面不小心又被解引用了。非常重要啊这一点！
好了！这个“题外话”终于说完了。就这么简单说一次，知道个大概就可以了！下面就进入第三个部分：
三、malloc()以及free()的机制：
这个部分我今天才有了新的认识！而且是转折性的认识！所以，这部分可能会有更多一些认识上的错误！不对的地方请大家帮忙指出！
事实上，仔细看一下free()的函数原型，也许也会发现似乎很神奇，free()函数非常简单，只有一个参数，只要把指向申请空间的指针传递给free()中的参数就可以完成释放工作！这里要追踪到malloc()的申请问题了。申请的时候实际上占用的内存要比申请的大。因为超出的空间是用来记录对这块内存的管理信息。先看一下在《UNIX环境高级编程》中第七章的一段话：
大多数实现所分配的存储空间比所要求的要稍大一些，额外的空间用来记录管理信息——分配块的长度，指向下一个分配块的指针等等。这意味着如果写过一个已分配区的尾端，则会改写后一块的管理信息。这种类型的错误是灾难性的，但是因为这种错误不会很快就暴露出来，所以也就很难发现。将指向分配块的指针向后移动也可能会改写本块的管理信息。
以上这段话已经给了我们一些信息了。malloc()申请的空间实际我觉得就是分了两个不同性质的空间。一个就是用来记录管理信息的空间，另外一个就是可用空间了。而用来记录管理信息的实际上是一个结构体。在C语言中，用结构体来记录同一个对象的不同信息是天经地义的事！下面看看这个结构体的原型：
struct mem_control_block {
int is_available; //这是一个标记？
int size; //这是实际空间的大小
};
对于size,这个是实际空间大小。这里其实我有个疑问，is_available是否是一个标记？因为我看了free()的源代码之后对这个变量感觉有点纳闷（源代码在下面分析）。这里还请大家指出！
所以，free()就是根据这个结构体的信息来释放malloc()申请的空间！而结构体的两个成员的大小我想应该是操作系统的事了。但是这里有一个问题，malloc()申请空间后返回一个指针应该是指向第二种空间，也就是可用空间！不然，如果指向管理信息空间的话，写入的内容和结构体的类型有可能不一致，或者会把管理信息屏蔽掉，那就没法释放内存空间了，所以会发生错误！（感觉自己这里说的是废话）
好了！下面看看free()的源代码，我自己分析了一下，觉得比起malloc()的源代码倒是容易简单很多。只是有个疑问，下面指出！
// code...
void free(void *ptr)
{
struct mem_control_block *fre;
fre = ptr - sizeof(struct mem_control_block);
fre->is_available = 1;
return;
}
看一下函数第二句，这句非常重要和关键。其实这句就是把指向可用空间的指针倒回去，让它指向管理信息的那块空间，因为这里是在值上减去了一个结构体的大小！后面那一句free->is_available = 1;我有点纳闷！我的想法是：这里is_available应该只是一个标记而已！因为从这个变量的名称上来看，is_available 翻译过来就是“是可以用”。不要说我土！我觉得变量名字可以反映一个变量的作用，特别是严谨的代码。这是源代码，所以我觉得绝对是严谨的！！这个变量的值是1，表明是可以用的空间！只是这里我想了想，如果把它改为0或者是其他值不知道会发生什么事？！但是有一点我可以肯定，就是释放绝对不会那么顺利进行！因为这是一个标记！
当然，这里可能还是有人会有疑问，为什么这样就可以释放呢？？我刚才也有这个疑问。后来我想到，释放是操作系统的事，那么就free()这个源代码来看，什么也没有释放，对吧？但是它确实是确定了管理信息的那块内存的内容。所以，free()只是记录了一些信息，然后告诉操作系统那块内存可以去释放，具体怎么告诉操作系统的我不清楚，但我觉得这个已经超出了我这篇文章的讨论范围了。
那么，我之前有个错误的认识，就是认为指向那块内存的指针不管移到那块内存中的哪个位置都可以释放那块内存！但是，这是大错特错！释放是不可以释放一部分的！首先这点应该要明白。而且，从free()的源代码看，ptr只能指向可用空间的首地址，不然，减去结构体大小之后一定不是指向管理信息空间的首地址。所以，要确保指针指向可用空间的首地址！不信吗？自己可以写一个程序然后移动指向可用空间的指针，看程序会有会崩！
关于free最后还是要在强调一下，只要你用malloc申请了空间就一定要在不需要用到这块内存的时候把这块申请的空间free掉。如果没有free那么就造成内存泄露了。虽然我们说在程序执行结束后所以的东西都可以归还给操作系统，但是要是把这个没有释放空间的程序拿出来放到另外一个程序中使用，那么后果就很难想象了。
最后可能想到malloc()的源代码看看malloc()到底是怎么分配空间的，这里面涉及到很多其他方面的知识，比如说对于分配内存方面的代码那是很底层的东西（源代码很长）！有兴趣的朋友可以自己去下载源代码去看看。在这里有点值得注意下，就是在32位的WIN平台下，不管申请
了多少空间都不会造成内存耗尽的现象，因为WIN使用的是虚拟内存，如果内存被申请完了就自动用硬盘代替了。所以如果申请了过分大的空间
，可能你的硬盘就受着很大的压力了。
四、另一个内存分配的函数——realloc的机制简介
关于realloc是怎么重新分配内存空间的，这里简单说一下吧。其实，realloc其实用得并不频繁，主要用于对已经申请的内存空间进行扩张或者缩小（一般情况下是用来扩张内存大小的）。当执行realloc时，系统会遍历并检测内存节点链的每一个节点，先找到了原来申请的那块内存空间，检查是否有足够的空间在原来这块空间上进行扩展。如果有的话，则在原来申请的空间的地址上进行扩展就可以了。如果没有呢，那就复杂一点了。那么，现在就又要重新找出一块足够大空间的内存，然后系统或者编译器会做这么几件事：1、分配一块新的足够大的内存空间；2、将旧地址的内容进行拷贝到新的空间；3、释放原来旧的内存空间；4、将指针重新指向新的内存空间的首地址。所以，在不同的编译器下，很可能用realloc申请后的地址是不一样的。
但是，这里有一个问题了。对于扩展旧内存，realloc是个效率很低的函数。为什么呢？尤其当你的程序建立了很多堆内存段的时候，遍历所有的节点会消耗大量的CPU时间。这样的话，还不如释放原来久的内存空间，重新申请一个新的空间。但realloc唯一的好处就是有可能不会产生内存碎片。而对于对旧内存的缩小，realloc不需要遍历所有的节点，它直接在旧内存收缩，但这样的结果是会产生内存碎片。
五、参考文献：
——《UNIX环境高级编程》
——《高质量C/C++编程指南》 林锐 著
关于这本《高质量C/C++编程指南》有点相关方面的内容说一点。我是没有资格去评论这本书怎么样，只是觉得这本书一些方面说的和
K&R(《The C programming Language》)里面有些不同。在CSDN或者CU上有不少人说这本书是垃圾，但我觉得里面不少地方还是值得参考的。
ID：林键
2006.8.4 初稿 不错的文章！！
《The C programming Language》中文版本的书我昨天还在看
感觉越到后面越难懂啊！！！
呵呵~ 不过时间了下 好象不行啊，
char *Ptr = NULL;
Ptr = (char *)malloc(100 * sizeof(char));
if (NULL == Ptr)
{
put_char(0x01); //发送数据表示不能分配内存
}
始终不能分配内存 不过时间了下 好象不行啊，
char *Ptr = NULL;
Ptr = (char *)malloc(100 * sizeof(char));
if (NULL == Ptr)
{
put_char(0x01); //发送数据表示不能分配内存
}
始终不能分配内存 内存分配方式
---------------------------------------------------------------------------------------------
内存分配方式有三种：
---------------------------
（1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。 例如全局变量static变量。
（2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储 单元自动被释放。栈内存 分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
常见的内存错误及其对策
------------------------------------------------------------------------------------------
发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。
常见的内存错误及其对策如下：
1>内存分配未成功，却使用了它。
------------------------------------------
编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检 指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存，应该用if(p==NULL) 或if(p=NULL)进行防错处理。
2>内存分配虽然成功，但是尚未初始化就引用它
------------------------------------------
犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初 错误（例如数组）。
内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所 以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。
3>内存分配成功并且已经初始化，但操作越过了内存的边界。
------------------------------------------
例如在使用数组时经常发生下标"多1"或者"少1"的操作。特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。
4>忘记了释放内存，造成内存泄露。
------------------------------------------
含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。
5>释放了内存却继续使用它。
------------------------------------------
有三种情况：
（1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。
（2）函数的return语句写错了，注意不要返回指向"栈内存"的"指针"或者"引用"，因为该内存在函数体结束时被自动销毁。
（3）使用free或delete释放了内存后，没有将指针设置为NULL。导致产生"野指针"。
【规则1】用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。
【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。
【规则3】避免数组或指针的下标越界，特别要当心发生"多1"或者"少1"操作。
【规则4】动态内存的申请与释放必须配对，防止内存泄漏。
【规则5】用free或delete释放了内存之后，立即将指针设置为NULL，防止产生"野指针"。
------------------------------------------------------------------------------------
指针与数组的对比
-----------------
C++/C程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。
数组
-------------
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。
指针
--------------
指针可以随时指向任意类型的内存块，它的特征是"可变"，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。
下面以字符串为例比较指针与数组的特性。
1.修改内容
------------------------------------------
示例1中，字符数组a的容量是6个字符，其内容为hello\0。a的内容可以改变，如a= 'X'。
指针p指向常量字符串"world"（位于静态存储区，内容为world\0），常量字符串的内容是不可以被修改的。
从语法上看，编译器并不觉得语句p= ‘X'有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误。
示例7-3-1 修改数组和指针的内容
------------------------------
char a[] = "hello";
a = 'X';
cout << a << endl;
char *p = "world"; // 注意p指向常量字符串
p = 'X';// 编译器不能发现该错误cout << p << endl;
2.内容复制与比较
------------------------------------------
数组复制
--------
不能对数组名进行直接复制与比较。示例2中，若想把数组a的内容复制给数组b，不能用语句 b = a ，否则将产生编译错误。应该用标准库函数strcpy进行复制。同理，比较b和a的内容是否相同，不能用if(b==a) 来判断，应该用标准库函数strcmp进行比较。
指针复制
--------
语句p = a 并不能把a的内容复制指针p，而是把a的地址赋给了p。要想复制a的内容，可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存，再用strcpy进行字符串复制。同理，语句if(p==a) 比较的不是内容而是地址，应该用库函数strcmp来比较。
示例2 数组和指针的内容复制与比较
-----------------------------------
// 数组...
char a[] = "hello";
char b;
strcpy(b, a); //不能用b = a;
if(strcmp(b, a) == 0) // 不能用if (b == a)...
// 指针...
int len = strlen(a);
char *p = (char *)malloc(sizeof(char)*(len+1));
strcpy(p,a); // 不要用 p = a;
if(strcmp(p, a) == 0) // 不要用 if (p == a)...
3 计算内存容量
------------------------------------------
数组
----
用运算符sizeof可以计算出数组的容量（字节数）。
示例3中，sizeof(a)的值是12（注意别忘了'\0'）。
指针
----
指针p指向a，但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数，
相当于sizeof(char*)，而不是p所指的内存容量。
C++/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。
注意
----
当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
示例3中，不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)。
示例3 计算数组和指针的内存容量
-----------------------------
char a[] = "hello world";
char *p= a; cout<< sizeof(a) << endl;// 12字节
cout<< sizeof(p) << endl;// 4字节
示例3（b） 数组退化为指针
-----------------------------
void Func(char a)
{
cout<< sizeof(a) << endl;// 4字节而不是100字节
}
4指针参数是如何传递内存的？
------------------------------------------
如果函数的参数是一个指针，不要指望用该指针去申请动态内存。
示例4-1中，Test函数的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL，为什么？
示例4-1 试图用指针参数申请动态内存
----------------------------------
void GetMemory(char *p, int num)
{
p = (char *)malloc(sizeof(char) * num);
}
void Test(void)
{
char *str = NULL;
GetMemory(str, 100);// str 仍然为 NULL
strcpy(str, "hello"); // 运行错误
}
毛病出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本，
指针参数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，
就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。
在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。
所以函数GetMemory并不能输出任何东西。
事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。
如果非得要用指针参数去申请内存，那么应该改用"指向指针的指针"，见示例4-2。
示例4-2用指向指针的指针申请动态内存
------------------------------------
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(sizeof(char) * num);
}
void Test2(void)
{
char *str = NULL;
GetMemory2(&str, 100); // 注意参数是 &str，而不是str
strcpy(str, "hello");
cout<< str << endl;
free(str);
}
由于"指向指针的指针"这个概念不容易理解，我们可以用函数返回值来传递动态内存。
这种方法更加简单，见示例4-3。
示例4-3 用函数返回值来传递动态内存
-----------------------------------
char *GetMemory3(int num)
{
char *p = (char *)malloc(sizeof(char) * num);
return p;
}
void Test3(void)
{
char *str = NULL;
str = GetMemory3(100);
strcpy(str,"hello");
cout<< str << endl;
free(str);
}
用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。这里强调不要用return语句返回指向"栈内存"的指针，因为该内存在函数结束时自动消亡，见示例4-4。
示例4-4 return语句返回指向"栈内存"的指针
--------------------------------------------
char *GetString(void)
{
char p[] = "hello world";
return p;// 编译器将提出警告
}
void Test4(void)
{
char *str = NULL;str = GetString();// str 的内容是垃圾
cout<< str << endl;
}
用调试器逐步跟踪Test4，发现执行str = GetString语句后str不再是NULL指针，
但是str的内容不是"hello world"而是垃圾。
如果把示例4-4改写成示例4-5，会怎么样？
示例4-5 return语句返回常量字符串
-----------------------------------
char *GetString2(void)
{
char *p = "hello world";
return p;
}
void Test5(void)
{
char *str = NULL;
str = GetString2();
cout<< str << endl;
}
函数Test5运行虽然不会出错，但是函数GetString2的设计概念却是错误的。
因为GetString2内的"hello world"是常量字符串，位于静态存储区，它在程序生命期内恒定不变。
无论什么时候调用GetString2，它返回的始终是同一个"只读"的内存块。
5 free和delete把指针怎么啦？
------------------------------------------
别看free和delete的名字恶狠狠的（尤其是delete），
它们只是把指针所指的内存给释放掉，但并没有把指针本身干掉。
用调试器跟踪示例5，发现指针p被free以后其地址仍然不变（非NULL），
只是该地址对应的内存是垃圾，p成了"野指针"。
如果此时不把p设置为NULL，会让人误以为p是个合法的指针。
如果程序比较长，我们有时记不住p所指的内存是否已经被释放，
在继续使用p之前，通常会用语句if (p !=NULL)进行防错处理。
很遗憾，此时if语句起不到防错作用，因为即便p不是NULL指针，
它也不指向合法的内存块。
示例5p成为野指针
--------------------
char *p = (char *) malloc(100);
strcpy(p, "hello");
free(p); // p 所指的内存被释放，但是p所指的地址仍然不变 ...
if(p != NULL) // 没有起到防错作用
{ strcpy(p, "world"); // 出错
}
6 动态内存会被自动释放吗？
------------------------------------------
函数体内的局部变量在函数结束时自动消亡。很多人误以为示例6是正确的。
理由是p是局部的指针变量，它消亡的时候会让它所指的动态内存一起完蛋。这是错觉！
示例7-6 试图让动态内存自动释放
------------------------------
void Func(void)
{
char *p = (char *) malloc(100); // 动态内存会自动释放吗？
}
我们发现指针有一些"似是而非"的特征：
------------------------------------
（1）指针消亡了，并不表示它所指的内存会被自动释放。
（2）内存被释放了，并不表示指针会消亡或者成了NULL指针。
这表明释放内存并不是一件可以草率对待的事。也许有人不服气，
一定要找出可以草率行事的理由：
如果程序终止了运行，一切指针都会消亡，动态内存会被操作系统回收。
既然如此，在程序临终前，就可以不必释放内存、不必将指针设置为NULL了。
终于可以偷懒而不会发生错误了吧？
想得美。如果别人把那段程序取出来用到其它地方怎么办？
7 杜绝"野指针"
------------------------------------------
"野指针"不是NULL指针，是指向"垃圾"内存的指针。
人们一般不会错用NULL指针，因为用if语句很容易判断。
但是"野指针"是很危险的，if语句对它不起作用。
"野指针"的成因主要有两种：
（1）指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，
它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，
要么将指针设置为NULL，要么让它指向合法的内存。例如
char *p = NULL;
char *str = (char *) malloc(100);
（2）指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。参见7.5节。
（3）指针操作超越了变量的作用范围。这种情况让人防不胜防，示例程序如下：
class A
{
public:
void Func(void){ cout << "Func of class A" << endl;
}
void Test(void)
{
A*p;
{
Aa;
p = &a; // 注意 a 的生命期
}
p->Func();// p是"野指针"
}
函数Test在执行语句p->Func()时，对象a已经消失，而p是指向a的，所以p就成了"野指针"。
但奇怪的是我运行这个程序时居然没有出错，这可能与编译器有关。
8 有了malloc/free为什么还要new/delete ？
------------------------------------------
malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。
它们都可用于申请动态内存和释放内存。
对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。
对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。
由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，
不能够把执行构造函数和析构函数的任务强加于malloc/free。
因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运
算符delete。注意new/delete不是库函数。
我们先看一看malloc/free和new/delete如何实现对象的动态内存管理，见示例8。
示例8 用malloc/free和new/delete如何实现对象的动态内存管理
-------------------------------------------------------------
class Obj
{
public :
Obj(void){ cout << "Initialization" << endl; }
~Obj(void){cout << "Destroy" << endl; }
void Initialize(void){ cout << "Initialization" << endl; }
void Destroy(void){ cout << "Destroy" << endl; }
};
void UseMallocFree(void)
{
Obj*a = (obj *)malloc(sizeof(obj)); // 申请动态内存
a->Initialize(); // 初始化
a->Destroy(); // 清除工作
free(a);// 释放内存
}
void UseNewDelete(void)
{
Obj*a = new Obj;// 申请动态内存并且初始化
delete a;// 清除并且释放内存
}
类Obj的函数Initialize模拟了构造函数的功能，函数Destroy模拟了析构函数的功能。
函数UseMallocFree中，由于malloc/free不能执行构造函数与析构函数，
必须调用成员函数Initialize和Destroy来完成初始化与清除工作。
函数UseNewDelete则简单得多。
所以我们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。
由于内部数据类型的"对象"没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。
既然new/delete的功能完全覆盖了malloc/free，为什么C++不把malloc/free淘汰出局呢？
这是因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。
如果用free释放"new创建的动态对象"，那么该对象因无法执行析构函数而可能导致程序出错。
如果用delete释放"malloc申请的动态内存"，理论上讲程序不会出错，但是该程序的可读性很差。
所以new/delete必须配对使用，malloc/free也一样。
9 内存耗尽怎么办？
------------------------------------------
如果在申请动态内存时找不到足够大的内存块malloc和new将返回NULL指针，宣告内存申请失败。
通常有三种方式处理"内存耗尽"问题。
（1）判断指针是否为NULL，如果是则马上用return语句终止本函数。例如：
void Func(void)
{
A*a = new A;
if(a == NULL)
{
return;
}
...
}
（2）判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。例如：
void Func(void)
{
A*a = new A;
if(a == NULL)
{
cout << "Memory Exhausted" << endl;
exit(1);
}
...
}
（3）为new和malloc设置异常处理函数。
例如Visual C++可以用_set_new_hander函数为new设置用户自己定义的异常处理函数，
也可以让malloc享用与new相同的异常处理函数。详细内容请参考C++使用手册。
上述（1）（2）方式使用最普遍。如果一个函数内有多处需要申请动态内存，
那么方式（1）就显得力不从心（释放内存很麻烦），应该用方式（2）来处理。
很多人不忍心用exit(1)，问："不编写出错处理程序，让操作系统自己解决行不行？"
不行。如果发生"内存耗尽"这样的事情，一般说来应用程序已经无药可救。
如果不用exit(1) 把坏程序杀死，它可能会害死操作系统。
道理如同：如果不把歹徒击毙，歹徒在老死之前会犯下更多的罪。
有一个很重要的现象要告诉大家。对于32位以上的应用程序而言
，无论怎样使用malloc与new，几乎不可能导致"内存耗尽"。
我在Windows 98下用Visual C++编写了测试程序，见示例9。
这个程序会无休止地运行下去，根本不会终止。
因为32位操作系统支持"虚存"，内存用完了，自动用硬盘空间顶替。
我只听到硬盘嘎吱嘎吱地响，Window 98已经累得对键盘、鼠标毫无反应。
我可以得出这么一个结论：对于32位以上的应用程序，"内存耗尽"错误处理程序毫无用处。这下可把Unix和Windows程序员们乐坏了：反正错误处理程序不起作用，我就不写了，省了很多麻烦。
我不想误导读者，必须强调：不加错误处理将导致程序的质量很差，千万不可因小失大。
示例9试图耗尽操作系统的内存
void main(void)
{
float *p = NULL;
while(TRUE)
{
p = new float;
cout << "eat memory" << endl;
if(p==NULL) exit(1);
}
}
10 malloc/free 的使用要点
------------------------------------------
函数malloc的原型如下：
void * malloc(size_t size);
用malloc申请一块长度为length的整数类型的内存，程序如下：
int*p = (int *) malloc(sizeof(int) * length);
我们应当把注意力集中在两个要素上："类型转换"和"sizeof"。
malloc返回值的类型是void *，所以在调用malloc时要显式地进行类型转换，
将void * 转换成所需要的指针类型。
malloc函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数。
我们通常记不住int,float等数据类型的变量的确切字节数。例如int变量在16位系统下是2个字节
，在32位下是4个字节；而float变量在16位系统下是4个字节，在32位下也是4个字节。
最好用以下程序作一次测试：
cout << sizeof(char) << endl;
cout << sizeof(int) << endl;
cout << sizeof(unsigned int) << endl;
cout << sizeof(long) << endl;
cout << sizeof(unsigned long) << endl;
cout << sizeof(float) << endl;
cout << sizeof(double) << endl;
cout << sizeof(void *) << endl;
在malloc的"()"中使用sizeof运算符是良好的风格，但要当心有时我们会昏了头，写出 p = malloc(sizeof(p))这样的程序来。
函数free的原型如下：
void free( void * memblock );
为什么free函数不象malloc函数那样复杂呢？这是因为指针p的类型以及它所指的内存的容量事先都是知道的，语句free(p)能正确地释放内存。如果p是NULL指针，那么free对p无论操作多少次都不会出问题。
如果p不是NULL指针，那么free对p连续操作两次就会导致程序运行错误。
11 new/delete 的使用要点
------------------------------------------
运算符new使用起来要比函数malloc简单得多，例如：
int*p1 = (int *)malloc(sizeof(int) * length);
int*p2 = new int;
这是因为new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，
new在创建动态对象的同时完成了初始化工作。
如果对象有多个构造函数，那么new的语句也可以有多种形式。
例如
class Obj
{
public :
Obj(void);// 无参数的构造函数
Obj(int x);// 带一个参数的构造函数
...
}
void Test(void)
{
Obj*a = new Obj;
Obj*b = new Obj(1); // 初值为1
...
delete a;
delete b;
}
如果用new创建对象数组，那么只能使用对象的无参数构造函数。例如
Obj*objects = new Obj; // 创建100个动态对象
不能写成
Obj*objects = new Obj(1);// 创建100个动态对象的同时赋初值1
在用delete释放对象数组时，留意不要丢了符号‘[]'。例如
delete []objects; // 正确的用法
delete objects; // 错误的用法
后者相当于delete objects，漏掉了另外99个对象。
12 一些心得体会
------------------------------------------
（1）越是怕指针，就越要使用指针。不会正确使用指针，肯定算不上是合格的程序员。
（2）必须养成"使用调试器逐步跟踪程序"的习惯，只有这样才能发现问题的本质。
最后，说一句："呵呵，有点长，不知道大家有没有时间把它看完？" {:call:}真正研究这部分非常的好 这么好的帖子，居然沉了，谢谢楼主，我正需要~ 内存管理，mark. 好贴！我感觉is_available变量是用来告诉操作系统这个内存可以释放的标记，当为1时，操作系统会释放这段空间；当为0时，不做操作。 感觉，裸奔的不用内存管理也行，分配内存也是要消耗时间的 还在裸奔，不一定用得上，不过这么好的帖子必须顶！ 好贴，学习了！ 好贴，mark 标记，malloc+free malloc正在研究这部分
页:
[1]