2018年网站开发语言排行,拼团做的比较好的网站,wordpress图集,北京seo实战培训班为什么需要指针?
#xff08;1#xff09;指针的使用使得不同区域的代码可以轻易的共享内存数据。当然你也可以通过数据的复制达到相同的效果#xff0c;但是这样往往效率不太好#xff0c;因为诸如结构体等大型数据#xff0c;占用的字节数多#xff0c;复制很消耗性能…
为什么需要指针?
1指针的使用使得不同区域的代码可以轻易的共享内存数据。当然你也可以通过数据的复制达到相同的效果但是这样往往效率不太好因为诸如结构体等大型数据占用的字节数多复制很消耗性能。但使用指针就可以很好的避免这个问题因为任何类型的指针占用的字节数都是一样的。
2指针使得一些复杂的链接性的数据结构的构建成为可能比如链表链式二叉树等等。
3有些操作必须使用指针。如操作申请的堆内存。 C语言中的一切函数调用中实参传递给形参的机理都是按值传递(pass by value)如果我们要在函数中修改被传递过来的对象就必须通过这个对象的指针来完成。
指针是什么
任何程序数据载入内存后在内存都有他们的地址这就是指针。为了保存一个数据在内存中的地址就需要指针变量。指针是程序数据在内存中的地址而指针变量是用来保存这些地址的变量。
为什么程序中的数据会有自己的地址操作系统将DRAM等硬件和软件结合起来给程序员提供的一种对物理内存使用的抽象。这种抽象机制使得程序使用的是虚拟存储器,而不是直接操作物理存储器。所有的虚拟地址形成的集合就是虚拟地址空间。 虚拟存储器是一个很大的线性的字节数组。每一个字节都是固定的大小由8个二进制位组成。最关键的是每一个字节都有一个唯一的编号,编号从0开始一直到最后一个字节。由于内存中的每一个字节都有一个唯一的编号因此在程序中使用的变量常量甚至数函数等数据当他们被载入到内存中后都有自己唯一的一个编号这个编号就是这个数据的地址。指针就是这样形成的。
#include stdio.h
int main(void)
{char ch a;int num 97;printf(ch 的地址:%p\n,ch); //ch 的地址:0028FF47printf(num的地址:%p\n,num); //num的地址:0028FF40return 0;
}
指针的值实质是内存单元即字节的编号所以指针 单独从数值上看也是整数他们一般用16进制表示。指针的值虚拟地址值使用一个机器字的大小来存储。
我们可以大致画出变量ch和num在内存模型中的存储。假设 char占1个字节int占4字节 总结资源有限的情况下使用合理的资产使用管理机制。抽象的事物更加简单稳定特定的事物更加复杂易变。底层通过给上层提供抽象服务来获得利益上层通过使用底层的抽象来获得便利。
变量和内存 为了简单起见这里就用上面例子中的 int num 97 这个局部变量来分析变量在内存中的存储模型。 已知num的类型是int占用了4个字节的内存空间其值是97地址是0028FF40。从以下几个方面去分析。
1、内存的数据 内存的数据就是变量的值对应的二进制一切都是二进制。97的二进制是 : 00000000 00000000 00000000 0110000 , 但使用的小端模式存储时低位数据存放在低地址所以图中画的时候是倒过来的。
2、内存数据的类型 内存的数据类型决定了这个数据占用的字节数以及计算机将如何解释这些字节。num的类型是int因此将被解释为 一个整数。相同的内存数据以不同的数据类型去解析的时候会得到不同的值所以数据的类型是非常重要的。
3、内存数据的名称 内存的名称就是变量名。实质上内存数据都是以地址来标识的根本没有内存的名称这个说法这只是高级语言提供的抽象机制 方便我们操作内存数据。而且在C语言中并不是所有的内存数据都有名称例如使用malloc申请的堆内存就没有。
4、内存数据的地址 如果一个类型占用的字节数大于1则其变量的地址就是其占用的所有字节的地址值最小的那个字节的地址。因此num的地址是 0028FF40。 内存的地址用于标识这个内存块。
5、内存数据的生命周期 num是main函数中的局部变量因此当main函数被启动时它被分配于栈内存上当main执行结束时消亡。 如果一个数据一直占用着他的内存那么我们就说他是“活着的”如果他占用的内存被回收了则这个数据就“消亡了”。C语言中的程序数据会按照他们定义的位置数据的种类修饰的关键字等因素决定他们的生命周期特性。实质上我们程序使用的内存会被逻辑上划分为栈区堆区静态数据区代码区。不同的区域的数据有不同的生命周期和读写权限。
指针变量和指向关系
用来保存指针的变量就是指针变量。如果指针变量p1保存了变量 num的地址则就说p1指向了变量num可以说p1指向了num所在的内存块这种指向关系在图中一般用箭头表示。 上图中指针变量p1指向了num所在的内存块 即从地址0028FF40开始的4个byte 的内存块。
定义指针变量
C语言中定义变量时在变量名 前 写一个 * 星号这个变量就变成了对应变量类型的指针变量。必要时要加( ) 来避免优先级的问题。 int a ; //int类型变量 a
int* p ; //int* 变量p
int arr[3]; //arr是包含3个int元素的数组
int (* parr )[3]; //parr是一个指向【包含3个int元素的数组】的指针变量
int* p_int; //指向int类型变量的指针
double* p_double; //指向double类型变量的指针
struct Student *p_struct; //结构体类型的指针
int(*p_func)(int,int); //指向返回类型为int有2个int形参的函数的指针
int(*p_arr)[3]; //指向含有3个int元素的数组的指针
int** p_pointer; //指向 一个整形变量指针的指针
取地址
使用运算符取得一个变量的地址。
int add(int a , int b)
{return a b;
}
int main(void)
{int num 97;float score 10.00F;int arr[3] {1,2,3};int* p_num num;float* p_score score;int (*p_arr)[3] arr; int (*fp_add)(int ,int ) add; //p_add是指向函数add的函数指针return 0;
}
特殊的情况他们并不一定需要使用取地址
数组名的值就是这个数组的第一个元素的地址。
函数名的值就是这个函数的地址。
字符串字面值常量作为右值时就是这个字符串对应的字符数组的名称,也就是这个字符串在内存中的地址。
int add(int a , int b){return a b;
}
int main(void)
{int arr[3] {1,2,3};//-----------------------int* p_first arr;int (*fp_add)(int ,int ) add;const char* msg Hello world;return 0;
}解地址
我们需要一个数据的指针变量干什么当然使用通过它来操作读/写它指向的数据啦。对一个指针解地址就可以取到这个内存数据解地址 的写法就是在指针的前面加一个*号。
解指针的实质是从指针指向的内存块中取出这个内存数据。
int main(void)
{int age 19;int*p_age age;*p_age 20; //通过指针修改指向的内存数据printf(age %d\n,*p_age); //通过指针读取指向的内存数据printf(age %d\n,age);return 0;
}
指针之间的赋值
指针赋值和int变量赋值一样就是将地址的值拷贝给另外一个。指针之间的赋值是一种浅拷贝是在多个编程单元之间共享内存数据的高效的方法。
int* p1 num;
int* p3 p1;
//通过指针 p1 、 p3 都可以对内存数据 num 进行读写如果2个函数分别使用了p1 和p3那么这2个函数就共享了数据num。
空指针
指向空或者说不指向任何东西。在C语言中我们让指针变量赋值为NULL表示一个空指针而C语言中NULL实质是 ((void*)0) 在C中NULL实质是0。
换种说法任何程序数据都不会存储在地址为0的内存块中它是被操作系统预留的内存块。
下面代码摘自 stddef.h
#ifdef __cplusplus#define NULL 0
#else #define NULL ((void *)0)
#endif 坏指针
指针变量的值是NULL或者未知的地址值或者是当前应用程序不可访问的地址值这样的指针就是坏指针不能对他们做解指针操作否则程序会出现运行时错误导致程序意外终止。
任何一个指针变量在做 解地址操作前都必须保证它指向的是有效的可用的内存块否则就会出错。坏指针是造成C语言Bug的最频繁的原因之一。
下面的代码就是错误的示例。
int*p NULL;
*p 10; //不能对NULL解地址int*p;
*p 10; //不能对一个未知的地址解地址
int*p (int*)1000;
*p 10; //不能对一个可能不属于本程序的内存的地址的指针解地址
int*p (int*)1000;
*p 10; //不能对一个可能不属于本程序的内存的地址的指针解地址指针的2个重要属性
指针也是一种数据指针变量也是一种变量因此指针 这种数据也符合前面 变量和内存 主题中的特性。 这里我只想强调2个属性 指针的类型指针的值。
int main(void)
{int num 97;int *p1 num;char* p2 (char*)(num);printf(%d\n,*p1); //输出 97putchar(*p2); //输出 areturn 0;
}
指针的值很好理解如上面的num 变量 其地址的值就是0028FF40 因此 p1的值就是0028FF40。数据的地址用于在内存中定位和标识这个数据因为任何2个内存不重叠的不同数据的地址都是不同的。
指针的类型指针的类型决定了这个指针指向的内存的字节数并如何解释这些字节信息。一般指针变量的类型要和它指向的数据的类型匹配。
由于num的地址是0028FF40因此p1 和 p2的值都是0028FF40
*p1 : 将从地址0028FF40 开始解析因为p1是int类型指针int占4字节因此向后连续取4个字节并将这4个字节的二进制数据解析为一个整数 97。
*p2 : 将从地址0028FF40 开始解析因为p2是char类型指针char占1字节因此向后连续取1个字节并将这1个字节的二进制数据解析为一个字符即a。
同样的地址因为指针的类型不同对它指向的内存的解释就不同得到的就是不同的数据。
void*类型指针
由于void是空类型因此void*类型的指针只保存了指针的值而丢失了类型信息我们不知道他指向的数据是什么类型的只知道这个数据在内存中的起始地址如果想要完整的提取指向的数据程序员就必须对这个指针做出正确的类型转换然后再解指针。前面已经提到过数据的类型是正确解析出内存数据的关键相同的内存数据以不同的数据类型去解析的时候会得到不同的值。程序需要得到什么数据不光要知道其地址还要明确其类型因此编译器不允许直接对void*类型的指针做解指针操作。
结构体和指针
结构体指针有特殊的语法 - 符号
如果p是一个结构体指针则可以使用 p -成员 的方法访问结构体的成员。p-member 等价于 (*p).member。
typedef struct
{char name[31];int age;float score;
}Student;int main(void)
{Student stu {Bob , 19, 98.0};Student*ps stu;ps-age 20;ps-score 99.0;printf(name:%s age:%d\n,ps-name,ps-age);return 0;
}数组和指针
int ages[5]{10,9,8,7,6};
遍历数组
for(int i0;i5;i)printf(“%d\n”,ages[i]);
使用指针遍历数组
int *p;
pages;//也可以写成pages[0];指针变量p指向了数组的首元素
元素的地址
第一个元素的地址p ages[0]
第二个元素的地址p1 ages[1]
第三个元素的地址p2 ages[2]
元素的值
*p ages[0]
*(p1) ages[1]
*(p2) ages[2]
把指针当做数组来用
for(int i0;i5;i)printf(“%d\n”,*(pi));
1数组元素的三种访问形式
①数组名[下标]
②指针变量名[下标]
③*p1
2指针变量的1究竟是加多少这取决于指针的类型如果是char类型则加1个字节如果是int类型的则加4个字节。
3利用指针来接收一个数组指针变量指向了数组的首元素。
void change(int array[])等价于void change(int *array)。
前者存储的虽然是数组元素的首地址但是在传递时就已经变成指针了。
void change(int *array){
//Printf(“%d\n”,array[2]);
Printf(“%d\n”,*(array2));
}
Int main(){
Int ages[5]{1,2,3,4,5};
Change(ages);
}
调用的结果为数组的第三个元素3。
掌握字符串定义的两种方式。
① 利用数组字符串里边的字符是可以修改的适用于内容需要经常修改时。
② 利用指针一个常量字符串里面的字符不能修改适用于字符串的内容不需要修改且这个字符串经常被使用时。
二指针数组
整型数组数组中存放的都是整型数组。
指针数组数组中存放的都是指针。
int ages[5];
char *name[5]{“jack”,“rose”,“yang”};//字符串数组的常见写法
对应于
char name2[3][10]{“jack”,“rose”,“yang”};
保存字符串数组的两种方式
①指针数组字符串数组
②二维字符数组字符串数组 函数的参数和指针
C语言中实参传递给形参是按值传递的也就是说函数中的形参是实参的拷贝份形参和实参只是在值上面一样而不是同一个内存数据对象。这就意味着这种数据传递是单向的即从调用者传递给被调函数而被调函数无法修改传递的参数达到回传的效果。
有时候我们可以使用函数的返回值来回传数据在简单的情况下是可以的但是如果返回值有其它用途例如返回函数的执行状态量或者要回传的数据不止一个返回值就解决不了了。
传递变量的指针可以轻松解决上述问题。
通过指针传递数据给函数不是为了在函数中改变他指向的对象相反我们防止这个目标数据被改变。传递指针只是为了避免拷贝大型数据。考虑一个结构体类型Student。我们通过show函数输出Student变量的数据。
typedef struct
{char name[31];int age;float score;
}Student;//打印Student变量信息
void show(const Student * ps)
{printf(name:%s , age:%d , score:%.2f\n,ps-name,ps-age,ps-score);
}只是在show函数中取读Student变量的信息而不会去修改它为了防止意外修改我们使用了常量指针去约束。另外我们为什么要使用指针而不是直接传递Student变量呢
从定义的结构看出Student变量的大小至少是39个字节那么通过函数直接传递变量实参赋值数据给形参需要拷贝至少39个字节的数据极不高效。而传递变量的指针却快很多因为在同一个平台下无论什么类型的指针大小都是固定的X86指针4字节X64指针8字节远远比一个Student结构体变量小。
应用
现在有个要求写一个函数swap接收2个整型参数功能是互换两个实参的值。
void swap(char v1, char v2) {printf(更换前v1%d, v2%d\n, v1, v2);// 定义一个中间变量char temp;// 交换v1和v2的值temp v1;v1 v2;v2 temp; printf(更换后v1%d, v2%d\n, v1, v2);
}int main(){char a 10, b 9;printf(更换前a%d, b%d\n, a, b); swap(a, b); printf(更换后a%d, b%d, a, b);return 0;
}
虽然v1和v2的值被交换了但是变量a和b的值根本就没有换过来。因为基本数据类型作为函数实参时只是纯粹地将值传递给形参形参的改变并不影响实参。
应该使用交换两个值。
// 使用引用重写swap函数
void swap(int *v1, int *v2) {int temp v1;v1 v2;v2 temp;
}
如果没有指针使用值传递在一个函数的内部改变不了外部的实参。
应用
默认情况下一个函数只能有一个返回值有了指针我们可以实现函数有多返回值。
现在有个要求写一个函数sumAndMinus可以同时计算2个整型的和与差函数执行完毕后返回和与差(注意了这里要返回2个值
// 计算2个整型的和与差
int sumAndMinus(int v1, int v2, int *minus) {// 计算差并赋值给指针指向的变量*minus v1 - v2;// 计算和并返回和return v1 v2;
}
int main()
{// 定义2个int型变量int a 6, b 2;// 定义2个变量来分别接收和与差int sum, minus;// 调用函数sum sumAndMinus(a, b, minus);// 打印和printf(%d%d%d\n, a, b, sum);// 打印差printf(%d-%d%d\n, a, b, minus);return 0;
}
和与差都由同一个函数计算并返回出来。和是函数的直接返回值差是通过函数的第3个指针参数间接返回。因此有了指针我们可以让函数有无限个返回值。
深拷贝和浅拷贝
如果2个程序单元例如2个函数是通过拷贝 他们所共享的数据的 指针来工作的这就是浅拷贝因为真正要访问的数据并没有被拷贝。如果被访问的数据被拷贝了在每个单元中都有自己的一份对目标数据的操作相互 不受影响则叫做深拷贝。 指针和引用这个2个名词的区别。他们本质上来说是同样的东西。指针常用在C语言中而引用则用于诸如JavaC#等 在语言层面封装了对指针的直接操作的编程语言中。引用是编程语言提供给程序员的抽象机制而指针是操作系统提供给软件开发模型的抽象机制。
局部变量指针
如果不了解程序栈如何工作就很容易犯返回指向局部数据指针的错误看下面的例子
#includestdio.h
#includestdlib.h
int* allocateArray(int size, int value)
{int arr[size];for(int i 0; i size; i) {arr[i] value;}return arr;
}
int main()
{int* vector allocateArray(5, 45);for(int i 0; i 5; i) {printf(%d\n, vector[i]);}return 0;
}
一旦函数返回返回的数组地址也就无效因为函数的栈帧从栈中弹出了。有一种方法是把arr变量声明为static这样会把变量的作用域现在在函数内部但是分配在栈帧的外面避免其他函数覆写变量值
#includestdio.h
#includestdlib.h
int* allocateArray(int size, int value)
{static int arr[10];for(int i 0; i size; i) {arr[i] value;}return arr;
}
int main()
{int* vector allocateArray(5, 45);for(int i 0; i 5; i) {printf(%d\n, vector[i]);}return 0;
}
返回指针
从函数返回对象经常使用以下两种技术
使用malloc在函数内部分配内存并返回其地址调用者负责释放返回的内存传递一个对象给函数让函数修改它这样分配和释放对象的内存都是调用者的责任
#includestdio.h
#includestdlib.h
int* allocateArray(int size, int value)
{int* arr (int*)malloc(size * sizeof(int));for(int i 0; i size; i) {arr[i] value;}return arr;
}
int main()
{int* vector allocateArray(5, 45);for(int i 0; i 5; i) {printf(%d\n, vector[i]);}free(vector);return 0;
}
下面这个版本的allocateArray函数传递了一个数组指针、数组的长度和用来初始化数组元素的值返回指针只是为了方便
#includestdio.h
#includestdlib.h
int* allocateArray(int *arr, int size, int value)
{if(arr ! NULL) {for(int i 0; i size; i) {arr[i] value;}}return arr;
}
int main()
{int* vector (int*)malloc(5 * sizeof(int));allocateArray(vector, 5, 45);for(int i 0; i 5; i) {printf(%d\n, vector[i]);}free(vector);return 0;
}
传递指针的指针
将指针传递给函数的时候传递的是值如果希望修改原指针而不是指针的副本就需要传递指针的指针
#includestdio.h
#includestdlib.h
void allocateArray(int **arr, int size, int value)
{*arr (int*)malloc(size * sizeof(int));if(arr ! NULL) {for(int i 0; i size; i) {*(*arr i) value;}}
}
int main()
{int* vector NULL;allocateArray(vector, 5, 45);for(int i 0; i 5; i) {printf(%d\n, vector[i]);}free(vector);return 0;
} 指针与字符串
一个字符串由一个或多个字符组成因此我们可以用字符数组来存放字符串不过在数组的尾部要加上一个空字符\0。
char s[] mj;
上面的代码定义了一个字符数组s来存储字符串mj系统会自动在尾部加上一个空字符\0。
我们也可以直接用指针指向一个字符串省略定义字符数组这个步骤
#include string.h
int main(){// 定义一个字符串用指针s指向这个字符串char *s mj;// 使用strlen函数测量字符串长度int len strlen(s);printf(字符串长度%D, len);return 0;}
注意第6行我们直接用指针s指向了字符串mj并没有先创建一个字符数组。
指针指向字符串的其他方式
char *s;
s mj;
上面的指向方式也是正确的先定义指针变量再指向字符串。如果是字符数组就不允许这样做下面的做法是错误的。
char s[10];
s mj;
编译器肯定报第2行的错因为s是个常量代表数组的首地址不能进行赋值运算。
下面的做法也是错误的
char *s mj;*s like;
第3行代码相当于把字符串like存进s指向的那一块内存空间由第1行代码可以看出s指向的是mj的首字符m也就是说s指向的一块char类型的存储空间只有1个字节要like存进1个字节的空间内肯定内存溢出由第1行代码可以看出指针s指向的是字符串常量mj因此是不能再通过指针来修改字符串内容的就算是*s A这样看起来似乎正确的写法也是错误的因为s指向的一个常量字符串不允许修改它内部的字符。
指针处理字符串的注意
// 定义一个字符串变量lmjchar a[] lmj; // 将字符串的首字符改为L*a L; printf(%s, a);
可以实现。 char *p2 lmj;*p2 L; printf(%s, p2);
指针变量p2指向的是一块字符串常量正因为是常量所以它内部的字符是不允许修改的。
指向指针的指针
Int a10;
Int *pa;//指向int型的指针
Int **p1p;//指向指针的指针
Int ***p2p1;//三级指针 *p2相当于访问p1
**p2相当于访问p;
***p2相当于访问a;
*p1相当于访问p; 指向函数的指针
每一个函数本身也是一种程序数据一个函数包含了多条执行语句它被编译后实质上是多条机器指令的合集。在程序载入到内存后函数的机器指令存放在一个特定的逻辑区域代码区。既然是存放在内存中那么函数也是有自己的指针的。
C语言中函数名作为右值时就是这个函数的指针。
void echo(const char *msg){printf(%s,msg);
}
int main(void){void(*p)(const char*) echo; //函数指针变量指向echo这个函数p(Hello ); //通过函数的指针p调用函数等价于echo(Hello )echo(World\n);return 0;
}1.一个指针变量占用多少个字节的内存空间占用的空间是否会跟随所指向变量的类型而改变
指针变量在计算机内存中占用的空间大小并不会跟随它所指向的变量类型而改变。指针变量本身的大小是由其所运行的操作系统和处理器架构决定的主要用于存储一个内存地址。
在32位操作系统和处理器架构中指针变量通常占用4个字节这是因为32位地址能够寻址的最大空间为2^32个内存单元每个内存单元通常是一个字节所以需要32位来表示一个地址。
在64位操作系统和处理器架构中指针变量通常占用8个字节对应64位地址空间可以寻址更大的内存空间。
2.既然每个指针变量所占用的内存空间是一样的而且存储的都是地址为何指针变量还要分类型而且只能指向一种类型的变量比如指向int类型的指针、指向char类型的指针。
1指针运算的语义 不同类型的指针在进行指针算术运算时如增加或减少指针值时步长是不一样的。例如int *p 类型的指针加1将会移动到下一个int 变量的位置而char *p类型的指针加1则只会移动到下一个字符变量的位置。这是因为不同类型的变量在内存中占用的字节数不同。
2)数据的安全访问 - 编译器需要知道指针指向的数据类型以便在解引用时正确读取或写入适当数量的字节。例如解引用int *p时会读取4个字节而解引用char *p时仅读取1个字节。
(3)类型系统的安全性 C/C语言的类型系统要求指针必须与其指向的数据类型匹配以防止错误的数据访问和转换。这样有助于在编译阶段发现潜在的类型不匹配错误增强程序的健壮性和安全性。
(4)编译器的类型检查 编译器通过指针类型来执行类型检查确保只有兼容类型的指针之间才能互相赋值或比较这样可以阻止非法的内存访问。
(5) 函数接口的清晰性 当指针作为函数参数时指针类型明确了函数期望处理的数据类型使得函数接口更加清晰调用者不会混淆。 使用裸指针可能存在的问题
问题一难以区分指向的是单个对象还是一个数组 int *p new int; // 分配一个整型对象
*p 10;// 或者
int *arr new int[5]; // 分配一个包含5个整型元素的数组
arr[0] 10;
在指针 p 或 arr 上仅凭指针本身无法区分其指向的是单个对象还是数组。
问题二使用完指针之后无法判断是否应该销毁指针
void someFunction(int *ptr) {// ... 使用 ptr ...
} // 函数结束时如果不显式 delete ptr则可能会造成内存泄漏int main() {int *p new int;someFunction(p); // 函数结束后p 指向的内存如果没有被释放则会泄漏// 此处应加上 delete p;return 0;
}
问题三销毁方式不确定
struct CustomObject {~CustomObject() { /* 特殊清理逻辑 */ }
};CustomObject *createObject() {return new CustomObject();
}void cleanup(CustomObject *obj) {delete obj; // 可能有特殊清理方式
}int main() {CustomObject *obj createObject();// 如果不知道这里应该调用 cleanup(obj) 还是直接 delete obj// 则无法正确销毁对象// 正确做法取决于对象的实际生命周期管理策略// ...// 不清楚的情况下可能错误地// delete obj; // 或者忘记销毁return 0;
}
问题四无法确定使用 delete 还是 delete[]
int *singleInt new int;
int *arrayOfInts new int[5];// 错误的释放方式如果忘记了数组
delete singleInt; // 对数组应用了错误的 delete
delete arrayOfInts; // 应该使用 delete[]// 正确的释放方式应该是
delete singleInt;
delete[] arrayOfInts;
问题五路径控制问题和悬挂指针
class MyClass {
public:void useResource(int *resource) {if (resource ! nullptr) {// 使用 resource...// 如果在这条路径上抛出了异常那么下面的 delete 可能不会被执行delete resource;}}void errorProne() {int *p new int;try {useResource(p);} catch (...) {// 异常处理但没有释放 p这会导致内存泄漏}}
};
int main() {MyClass mc;mc.errorProne(); // 即使我们知道应该在这里释放 p也可能因为异常路径而导致泄漏return 0;
}
常见与指针有关的错误 对C程序员来说管理和使用虚拟内存是比较困难和容易出错的与内存有关的错误属于比较令人惊恐的错误因为它们在时间和空间上距离出错的地方有一段距离很难检查出来。 1 间接引用坏指针 前面说过在进程的虚拟地址空间中有较大的洞没有映射到任何有意义的数据如果我们试图间接引用一个指向这些洞的指针那么操作系统就会以段异常终止程序而且虚拟内存中的某些区域是只读的视图写这些区域将会以保护异常终止程序。 间接引用坏指针的一个常见示例是scanf错误假设我们想要使用scanf从stdin读一个整数到一个变量正确的方法是传递给scanf一个格式串和一个变量的地址 然而对于C程序员初学者而言很容易传递val的内容而不是它的地址。 这样就会出错scanf会把val内容解释为一个地址并试图将一个字写到这个位置最好的情况下程序立即终止糟糕的情况下val的内容对应一个合法的读写区域于是就覆盖了这块内存这可能在相当一段长时间之后造成灾难性、令人困惑的后果。 2 读未初始化的内存 虽然bss内存位置诸如未初始化的全局C变量总是被加载器初始化为0但是对于堆内存并不是这样一个常见的错误就是假设堆内存被初始化为0如下 这个实例中程序员不正确的假设y被初始化为0正确的实现方式是显式的将y[i]设置为0。 3 允许栈缓冲区溢出 一个程序如果不检查输入串的大小就写入栈中的目标缓冲区那么这个程序就会有缓冲区溢出错误例如下面程序因为gets函数复制一个任意长度的串到缓冲区为了纠正这个错误可以使用fgets函数这个函数限制了输入串的大小 4 假设指针和它们指向的对象是相同大小的 一种常见的错误时假设指向对象的指针和它们所指向的对象是相同大小的 这里的目的就是创建一个由n个指针组成的数组每个指针指向一个包含m个int的数组然而因为程序员在第5行将sizeof(int *)写成了sizeof(int)代码实际上创建的是一个int的数组。 这个代码只有在int和指向int的指针大小相同的机器上运行良好但是如果机器不是这样那么第7 8行很可能写到A数组结尾的地方。 5 造成错位错误 错位off-by-one错误是另一种很常见的覆盖错误来源 在第5行创建了一个n个元素的指针数组但是随后在第7行和第8行试图初始化这个数组的n1个元素在这个过程中覆盖了A数组后面某个内存位置。 6 引用指针而不是它所指向的对象 如果不太注意C操作符的优先级和结合性我们就会错误地操作指针而不是指针所指向的对象比如考虑下面的函数其目的是删除一个有*size项的二叉堆里的第一项然后对剩下的*size-1项重新建堆。 第6行目的是减少size指针所指向的整数的值然而因为一元运算符--和*的优先级相同从右向左结合所以第6行实际减少的指针自己的值而不是它所指向的数组的值。 7 误解指针运算 另一种常见的错误是忘记指针的算术操作是以它们指向的对象大小为单位来进行的而这种大小不一定是字节例如下面函数的目的是扫描一个int的数组并返回一个指针指向val的首次出现 然而每次扫描时第4行都把指针加4函数就不正确的扫描数组中每4个整数。 8 引用不存在的变量 没有太多经验的C程序员不理解栈的规则有时会引用不再合法的本地变量如下 这个函数返回一个指针指向栈里一个局部变量然后弹出它的栈帧尽管p仍然是一个合法的内存地址但是他已经不再指向一个合法的变量了。 9 引用空闲堆块中的数据 引用已经被释放了的堆块中的数据。 10 引起内存泄漏 内存泄漏是缓慢、隐性的杀手当程序员不小心忘记释放已分配块而在堆里创建了垃圾时就会发生这种问题例如下面函数分配了一个堆块X然后不释放就返回。 如果经常调用这个函数那么堆里就会充满垃圾对于像守护进程和服务器这样的程序内存泄漏是特别严重的根据定义这些程序是不会终止的。
