5、杜绝“野指针”

“野指针”不是null指针，是指向“垃圾”内存的指针。人们一般不会错用null指针，因为用if语句很容易判断。但是“野指针”是很危险的，if语句对它不起作用。 “野指针”的成因主要有两种：

（1）指针变量没有被初始化。

任何指针变量刚被创建时不会自动成为null指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为null，要么让它指向合法的内存。例如

1. char *p = null;  
2. char *str = (char *) malloc(100); 

（2）指针p被free或者delete之后，没有置为null，让人误以为p是个合法的指针。

（3）指针操作超越了变量的作用范围。

这种情况让人防不胜防，示例程序如下：

1. class a   
2. {   
3. 　public:  
4. void func(void){ cout << “func of class a” << endl; }  
5. };  
6. void test(void)  
7. {  
8. 　a *p;  
9. 　{  
10. a a;  
11. p = &a; // 注意 a 的生命期  
12. 　}  
13. 　p->func(); // p是“野指针”  
14. } 

函数test在执行语句p->func()时，对象a已经消失，而p是指向a的，所以p就成了“野指针”。但奇怪的是我运行这个程序时居然没有出错，这可能与编译器有关。

6、有了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如何实现对象的动态内存管理，见示例6。

1. class obj  
2. {  
3. 　public :  
4. obj(void){ cout << “initialization” << endl; }  
5. ~obj(void){ cout << “destroy” << endl; }  
6. void initialize(void){ cout << “initialization” << endl; }  
7. void destroy(void){ cout << “destroy” << endl; }  
8. };  
9. void usemallocfree(void)  
10. {  
11. 　obj *a = (obj *)malloc(sizeof(obj)); // 申请动态内存  
12. 　a->initialize(); // 初始化  
13. 　//…  
14. 　a->destroy(); // 清除工作  
15. 　free(a); // 释放内存  
16. }  
17. void usenewdelete(void)  
18. {  
19. 　obj *a = new obj; // 申请动态内存并且初始化  
20. 　//…  
21. 　delete a; // 清除并且释放内存  
22. }   
23. 　示例6 用malloc/free和new/delete如何实现对象的动态内存管理 

类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也一样。

7、内存耗尽怎么办？

如果在申请动态内存时找不到足够大的内存块，malloc和new将返回null指针，宣告内存申请失败。通常有三种方式处理“内存耗尽”问题。

（1）判断指针是否为null，如果是则马上用return语句终止本函数。例如：

1. void func(void)  
2. {  
3. 　a *a = new a;  
4. 　if(a == null)  
5. 　{  
6. return;  
7. 　}  
8. 　…  
9. } 

（2）判断指针是否为null，如果是则马上用exit(1)终止整个程序的运行。例如：

1. void func(void)  
2. {  
3. 　a *a = new a;  
4. 　if(a == null)  
5. 　{  
6. cout << “memory exhausted” << endl;  
7. exit(1);  
8. 　}  
9. 　…  
10. } 

（3）为new和malloc设置异常处理函数。例如visual c++可以用_set_new_hander函数为new设置用户自己定义的异常处理函数，也可以让malloc享用与new相同的异常处理函数。

上述（1）（2）方式使用最普遍。如果一个函数内有多处需要申请动态内存，那么方式（1）就显得力不从心（释放内存很麻烦），应该用方式（2）来处理。

很多人不忍心用exit(1)，问：“不编写出错处理程序，让操作系统自己解决行不行？”

不行。如果发生“内存耗尽”这样的事情，一般说来应用程序已经无药可救。如果不用exit(1) 把坏程序杀死，它可能会害死操作系统。道理如同：如果不把歹徒击毙，歹徒在老死之前会犯下更多的罪。

有一个很重要的现象要告诉大家。对于32位以上的应用程序而言，无论怎样使用malloc与new，几乎不可能导致“内存耗尽”。我在windows 98下用visual c++编写了测试程序，见示例7。这个程序会无休止地运行下去，根本不会终止。因为32位操作系统支持“虚存”，内存用完了，自动用硬盘空间顶替。我只听到硬盘嘎吱嘎吱地响，window 98已经累得对键盘、鼠标毫无反应。

我可以得出这么一个结论：对于32位以上的应用程序，“内存耗尽”错误处理程序毫无用处。这下可把unix和windows程序员们乐坏了：反正错误处理程序不起作用，我就不写了，省了很多麻烦。

我不想误导读者，必须强调：不加错误处理将导致程序的质量很差，千万不可因小失大。

1. void main(void)  
2. {  
3. 　float *p = null;  
4. 　while(true)  
5. 　{  
6. p = new float[1000000];   
7. cout << “eat memory” << endl;  
8. if(p==null)  
9. 　exit(1);  
10. 　}  
11. }示例7试图耗尽操作系统的内存

8、malloc/free 的使用要点

函数malloc的原型如下：

1. void * malloc(size_t size); 

用malloc申请一块长度为length的整数类型的内存，程序如下：

1. int *p = (int *) malloc(sizeof(int) * length); 

我们应当把注意力集中在两个要素上：“类型转换”和“sizeof”。

（1） malloc返回值的类型是void *，所以在调用malloc时要显式地进行类型转换，将void * 转换成所需要的指针类型。

（2） malloc函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数。我们通常记不住int, float等数据类型的变量的确切字节数。例如int变量在16位系统下是2个字节，在32位下是4个字节；而float变量在16位系统下是4个字节，在32位下也是4个字节。最好用以下程序作一次测试：

1. cout << sizeof(char) << endl;  
2. cout << sizeof(int) << endl;  
3. cout << sizeof(unsigned int) << endl;  
4. cout << sizeof(long) << endl;  
5. cout << sizeof(unsigned long) << endl;  
6. cout << sizeof(float) << endl;  
7. cout << sizeof(double) << endl;  
8. cout << sizeof(void *) << endl; 

在malloc的“()”中使用sizeof运算符是良好的风格，但要当心有时我们会昏了头，写出 p = malloc(sizeof(p))这样的程序来。

（3）函数free的原型如下：

1. void free( void * memblock ); 

为什么free函数不象malloc函数那样复杂呢？这是因为指针p的类型以及它所指的内存的容量事先都是知道的，语句free(p)能正确地释放内存。如果p是null指针，那么free对p无论操作多少次都不会出问题。如果p不是null指针，那么free对p连续操作两次就会导致程序运行错误。

9、new/delete 的使用要点

运算符new使用起来要比函数malloc简单得多，例如：

1. int *p1 = (int *)malloc(sizeof(int) * length);  
2. int *p2 = new int[length]; 

这是因为new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，new在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数，那么new的语句也可以有多种形式。例如

1. class obj  
2. {  
3. 　public :  
4. obj(void); // 无参数的构造函数  
5. obj(int x); // 带一个参数的构造函数  
6. …  
7. }  
8. void test(void)  
9. {  
10. 　obj *a = new obj;  
11. 　obj *b = new obj(1); // 初值为1  
12. 　…  
13. 　delete a;  
14. 　delete b;  
15. } 

如果用new创建对象数组，那么只能使用对象的无参数构造函数。例如

1. obj *objects = new obj[100]; // 创建100个动态对象 

不能写成

1. obj *objects = new obj[100](1);// 创建100个动态对象的同时赋初值1 

在用delete释放对象数组时，留意不要丢了符号‘[]’。例如

1. delete []objects; // 正确的用法  
2. delete objects; // 错误的用法 

后者相当于delete objects[0]，漏掉了另外99个对象。

10、一些心得体会

我认识不少技术不错的c++/c程序员，很少有人能拍拍胸脯说通晓指针与内存管理（包括我自己）。我最初学习c语言时特别怕指针，导致我开发第一个应用软件（约1万行c代码）时没有使用一个指针，全用数组来顶替指针，实在蠢笨得过分。躲避指针不是办法，后来我改写了这个软件，代码量缩小到原先的一半。

我的经验教训是：

（1）越是怕指针，就越要使用指针。不会正确使用指针，肯定算不上是合格的程序员。

（2）必须养成“使用调试器逐步跟踪程序”的习惯，只有这样才能发现问题的本质。

希望本文能够给你带来帮助。

【编辑推荐】

1. C++和Java 的缺省初始化问题
2. 介绍C/C++文件的操作函数
3. C++多线程调试和测试的注意事项
4. C/C++是程序员必须掌握的语言吗？
5. 浅谈C/C++中的static和extern关键字