标签：

　　之前多多少少已经整理或写过了一些跟指针有关的博文：

　　C++指针和引用

　　C++智能指针及其简单实现

　　函数指针和回调函数

　　指针和数组解析

　　指针的类型与指针所指向的类型

但对指针还是感觉一知半懂，所以再补充些相关知识。

指针作为函数参数

 　　先看一个小例子1：

 1 #include <stdio.h>
 2 #include <stdlib.h>    // mallock
 3 #include <string.h>    // strcpy
 4 
 5 void getmemory(char *p, int num)
 6 {
 7     p = (char *)malloc(sizeof(char) * num);
 8     //p = new char[sizeof(char) * num];
 9 }
10 
11 int main()
12 {
13     char *str = NULL;
14     getmemory(str, 100);            // str 依然为 NULL，且函数getmemory已造成内存泄露
15     strcpy(str, "Hello World!");    // 运行时错误
16 
17     return 0;
18 }

 　　这个程序在运行的时候会发生错误（且发生内存泄露，同时也没有判断内存是否申请成功），那具体是什么原因呢？且让我们再看一个小例子2：

 1 #include <stdio.h>
 2 #include <stdlib.h>    // mallock
 3 #include <string.h>    // strcpy
 4 
 5 void getmemory(char **p, int num)
 6 {
 7     *p = (char *)malloc(sizeof(char) * num);
 8     //p = new char[sizeof(char) * num];　　// new有构造函数（delete有析构函数），而malloc、free没有
 9 }
10 
11 int main()
12 {
13     char *str = NULL;
14     getmemory(&str, 100);                // str 已经不为 NULL
15     if (str != NULL)                     // 以防申请不成功
16     {
17         strcpy(str, "Hello World!");     // 运行不再错误
18         printf("%s\n", str);
19         free(str);                       // 记得释放内存
20     }
21     return 0;
22 }

　　这个程序能够如期正常工作。

　　下边让我们来看看例子1和例子2的区别在哪里。例1和例2的getmemory函数的参数都是按值传递的（PS. C语言中实际只有按值传递，只有C++中才有按值传递和按引用传递。），所以编译器会为函数的每个参数制作临时副本（局部变量）用于函数内运算，例如指针参数p的副本是_p，编译器使_p=p。博文C/C++中的函数参数传递机制(zz)就说的更为详细：

　　“

　　值传递（passl-by-value）过程中，被调函数的形式参数作为被调函数的局部变量处理，即在堆栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。

　　”

　　对于例1而言，调用函数getmemory过程可用下图表示：

　　所以在函数返回后，局部指针变量_p被清理（但其指向的内存没被释放），而指针变量p存储的还是原来的值（NULL）。

　　对于例2而言，调用函数getmemory过程可用下图表示：

　　这时，局部指针变量_p刚开始被初始化为指针变量p的地址，对其进行解引用可以得到p，所以接下来的内存申请实际是p在申请。这样即使函数返回，p所存的值（地址）仍然不变。

　　现在，我们就能够理解为什么如下函数

1 //int a = 1;
2 //int b = 2;
3 //swap(&a, &b);
4 void swap(int *p, int *q) 
5 {
6     int *t = p;
7     p = q;
8     q = t;
9 }

并不能交换a、b的值，而且还只是两个临时副本_p、_q交换了下指向的内存，在函数返回后就会被清理掉。

　　而如下函数

1 //int a = 1;
2 //int b = 2;
3 //swap(&a, &b);
4 void swap(int *p, int *q) 
5 {
6     int t = *p;
7     *p = *q;
8     *q = t;
9 }

却能够工作，因为我们是对a、b实际内存进行操作，当然可以将a、b调换过来。

　　关于swap函数，详细可参考博文你会swap吗，按值传递还是按引用？。

　　综上，在指针作为函数参数的情况下，要特别注意我们操作的是不是真正的内存！另外，编译器对按值传递的参数都会制作临时副本的特点也值得注意。

　　下边摘录部分比较经典的内存管理要点：

内存分配方式

　　内存分配方式有三种：

从静态存储区域分配

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

在栈上创建

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

从堆上分配，亦称动态内存分配

　　程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

常见的内存错误及其对策

　　发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。 常见的内存错误及其对策如下：

内存分配未成功，却使用了它

　　编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检查指针是否为null。如果指针p是函数的参数，那么在函数的入口处用assert(p!=null)进行检查。如果是用malloc或new来申请内存，应该用if(p==null) 或if(p!=null)进行防错处理。

内存分配虽然成功，但是尚未初始化就引用它

　　犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）。 内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。

内存分配成功并且已经初始化，但操作越过了内存的边界

　　例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。

忘记了释放内存，造成内存泄露

　　含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。

　　动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。

释放了内存却继续使用它

　　有三种情况：

• 程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。
• 函数的return语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数体结束时被自动销毁。
• 使用free或delete释放了内存后，没有将指针设置为null。导致产生“野指针”。

　　【规则1】用malloc或new申请内存之后，应该立即检查指针值是否为null。防止使用指针值为null的内存。

　　【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。

　　【规则3】避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作。

　　【规则4】动态内存的申请与释放必须配对，防止内存泄漏。

　　【规则5】用free或delete释放了内存之后，立即将指针设置为null，防止产生“野指针”。

关于指针的另一些问题

标签：

原文地址：http://www.cnblogs.com/xiehongfeng100/p/4734001.html