目录
01.5.1 指针的本质(间接访问原理)
1 指针的定义
内存区域中的每字节都对应一个编号,这个编号就是“地址”。如果在程序中定义了一个变量,那么在对程序进行编译时,系统就会给这个变量分配内存单元,按变量地址存取变量值的方式称为“直接访问”,如
scanf("%d",&i);
printf("%d",i);
另一种存取变量值的方式称为“间接访问”,即将变量i的地址存放到另一个变量中。
在C语言中,指针变量是一种特殊的变量,它用来存放变量地址。
指针变量的定义格式如下
基类型 *指针变量名;
例如
int *i_pointer;
指针与指针变量是两个概念。一个变量的地址称为该变量的“指针”。例如,地址2000是变量i的指针。如果有一个变量专门用来存放另一变量的地址(即指针),那么称它为“指针变量”。
例如,下图中的i_pointer就是一个指针变量。
![](https://i-blog.csdnimg.cn/direct/5c13b1ea97d543aa80455a7af18da971.png)
那么i_pointer本身占多大的内存空间呢?本章中编写的程序都是64位应用程序,寻址范围为64位即8字节,所以对于本章来说 sizeof(i_pointer)=8;如果编写的程序是32位,那么寻址范围就是4字节。(考研中往往会强调程序是32位的程序)
2 取地址操作符与取值操作符 指针本质
取地址操作符为&,通过该操作符可以获取一个变量的地址值。
取值操作符为*,通过该操作符可以得到一个地址对应的数据。
如下例所示,通过&i获取整型变量i的地址值,然后对整型指针变量i_pointer进行初始化,p中存储的是整型变量i的地址值,所以通过*i_pointer就可以获取整型变量i的值。i_pointer中存储的是一个绝对地址值,那为什么取值时会获取4字节大小的空间呢?这是因为i_pointer为整型变量指针,每个int型数据占用4字节大小的空间,所以i_pointer在取值时会访问4字节大小的空间,同时以整型值对内存进行解析。
【例】取地址与取值
#include <stdio.h>
int main() {
int i=5;
int *i_pointer;
//定义了一个指针变量,i_pointer就是指针变量名
//指针变量的初始化是某个变量取地址来赋值,不能随机写个数
i_pointer=&i;
printf("i=%d\n",i); //直接访问
printf("*i_pointer=%d\n",*i_pointer); //间接访问
return 0;
}
运行结果
注意:
(1)指针变量前面的“*”表示该变量为指针型变量。例如float *pointer_1;
注意指针变量名是 pointer_1,而不是*pointer_1。
(2)在定义指针变量时必须指定其类型,需要注意的是,只有整型变量的地址才能放到指向整型变量的指针变量中,例如,下面的赋值是错误的float a; int *pointer_1; pointer_1 = &a; //毫无意义而且会出错
(3)如果已执行了语句
pointer_1 = &a;
那么&*pointer 1的含义是什么呢?
“&”和“*”两个运算符的优先级别相同,但要按自右向左的方向结合。因此,&*pointer_1与&a相同,都表示变量a的地址,也就是pointer_1。
*&a的含义是什么呢?
首先进行&a运算,得到a的地址,再进行*运算,*&a和*pointer_1的作用是一样的,它
们都等价于变量a,即*&a与a等价。(4)声明指针变量时,实际上“*”是*a的一部分,只对a标识符起作用,但其余变量只是普通的整型变量,要声明三个指针变量,正确的语句如下
int *a,*b,*c;
01.5.2 指针的传递使用场景
1 指针的传递
首先来看例1。在本例的主函数中,定义了整型变量i其值初始化为10,然后通过子函数修改整型变量i的值。但是,执行语句printf("after change i=%d\n",i);后,打印的i的值仍为10,子函数change没有改变变量i的值。下面通过执行程序来查看为什么会出现这种情况。
【例1】指针的传递使用场景
#include <stdio.h>
//在子函数内去改变主函数中某个变量的值
void change(int j) //j是形参
{
j=5;
}
int main() {
int i=10;
printf("before change i=%d\n",i);
change(i); //C语言的函数调用是值传递,实参赋值给形参,j=i
printf("after change i=%d\n",i);
return 0;
}
执行结果
例1的原理图如图所示
![](https://i-blog.csdnimg.cn/direct/3a8898fbfccb4caea14fe2538de14834.png)
程序的执行过程其实就是内存的变化过程,我们需要关注的是栈空间的变化。当main函数开始执行时,系统会为main函数开辟函数栈空间,当程序走到int i时,main函数的栈空间就会为变量i分配4字节大小的空间,调用change函数时,系统会为change函数重新分配新的函数栈空间,并为形参变量j分配4字节大小的空间,在调用change(i)时,实际上是将i的值赋值给j,我们把这种效果称为值传递(C语言的函数调用均为值传递)。因此,当我们在change函数的函数栈空间内修改变量j的值后,change函数执行结束,其栈空间就会释放,j就不再存在,i的值不会改变。
有的人会问,难道就不能在子函数中修改 main 函数内的某个变量的值吗?答案是可以的,我们将程序进行了如例2所示的修改。
【例1.2】在子函数中修改main函数中某个变量的值。
#include <stdio.h>
//在子函数内去改变主函数中某个变量的值
void change(int *j)//j是形参
{
*j=5; //*j等价于变量i,只是间接访问
}
int main() {
int i=10;
printf("before change i=%d\n",i);
change(&i); //C语言的函数调用是值传递,实参赋值给形参,j=&i
printf("after change i=%d\n",i);
return 0;
}
执行结果
我们可以看到程序执行后,语句 printf("after change i=%d\n",i);打印的i的值为 5,难道C语言函数调用值传递的原理变了?并非如此,我们将变量i的地址传递给change函数时,实际效果是j=&i,依然是值传递,只是这时我们的j是一个指针变量,内部存储的是变量i的地址,所以通过*j就间接访问到了与变量i相同的区域,通过*j=5就实现了对变量i的值的改变,通过单步调试,依然可以看到变量j自身的地址是与变量i的地址不相等。
01.5.3 指针的偏移使用场景
1 指针的偏移
前面介绍了指针的传递。指针即地址,就像我们找到了一栋楼,这栋楼的楼号是B,那么往前就是 A,往后就是C,所以应用指针的另一个场景就是对其进行加减,但对指针进行乘除是没有意义的,就像家庭地址乘以5那样没有意义。在工作中,我们把对指针的加减称为指针的偏移,加就是向后偏移,减就是向前偏移。下面我们来看例1。
【例1】指针的偏移使用场景
#include <stdio.h>
//指针的偏移使用场景,也就是对指针进行加和减
#define N 5
int main() {
int a[N]={1,2,3,4,5}; //数组名内存储了数组的起始地址,a中存储的就是一个地址值
int *p; //定义指针变量p
p=a;
int i;
for(i=0;i<N;i++)
{
printf("%3d",*(p+i)); //这里写a[i]等价的
}
printf("\n-----------------\n");
p=&a[4]; //指针变量p指向了数组的最后一个元素
for(i=0;i<N;i++)
{
printf("%3d",*(p-i)); //这里写a[i]等价的
}
return 0;
}
运行结果
注意: float *p; p的偏移也是4个字节
如下图所示,数组名中存储着数组的起始地址 0x61fdf0,其类型为整型指针,所以可以将其赋值给整型指针变量p,可以从监视窗口中看到p+1的值为0x61fdf4。那么为什么加1后不是0x61fdf1呢?因为指针变量加1后,偏移的长度是其基类型的长度,也就是偏移 sizeof(int),这样通过*(p+1)就可以得到元素 a[1]。编译器在编译时,数组取下标的操作正是转换为指针偏移来完成的。
2 指针与一维数组
为什么一维数组在函数调用进行传递时,它的长度子函数无法知道呢?这是由于一维数组名中存储的是数组的首地址。
如下例所示,数组名c中存储是一个起始地址,所以子函数change中其实传入了一个地址。定义一个指针变量时,指针变量的类型要和数组的数据类型保持一致,通过取值操作,就可将“h”改为“H",这种方法称为指针法。获取数组元素时,也可以通过取下标的方式来获取数组元素并进行修改,这种方法称为下标法。
【例2】数组传递给子函数的实战练习
#include <stdio.h>
//指针与一维数组的传递
//数组名作为实参传递给子函数时,是弱化为指针的
//练习传递与偏移
void change(char *d)
{
*d='H';
d[1]='E'; //*(d+1)='E'与其等价
*(d+2)='E';
}
int main() {
char c[10]="hello";
change(c);
puts(c);
return 0;
}
运行结果
01.5.4 指针与malloc动态内存申请
很多读者在学习C语言的数组后都会觉得数组长度固定很不方便,其实C语言的数组长度固定是因为其定义的整型、浮点型、字符型变量、数组变量都在栈空间中,而栈空间的大小在编译时是确定的。如果使用的空间大小不确定,那么就要使用堆空间。
【例1.1】动态内存申请
#include <stdio.h>
#include <stdlib.h> //malloc使用的头文件
#include <string.h>
int main() {
int size; //size代表我们要申请多大字节的空间
char *p; //void*类型的指针不能偏移的,因此不会定义无类型指针
scanf("%d",&size); //输入要申请的空间大小
//malloc返回的void*代表无类型指针
p=(char*)malloc(size);
strcpy(p,"malloc success");
puts(p);
free(p); //释放申请的空间时,给的地址,必须是最初malloc返回给我们的地址
printf("free success\n");
return 0;
}
运行结果
首先我们来看 malloc 函数,在执行#include<stdlib.h> void*malloc(size_t size);时,需要给 malloc传递的参数是一个整型变量,因为这里的 size_t 即为int;返回值为 void*类型的指针,void*类型的指针只能用来存储一个地址而不能进行偏移,因为 malloc并不知道我们申请的空间用来存放什么类型的数据,所以确定要用来存储什么类型的数据后,都会将 void*强制转换为对应的类型。在上例中我们用来存储字符,所以将其强制转换为char*类型。
注意:指针本身大小(int 8字节 float 8字节 64位),和其指向的空间大小,是两码事,不能和前面的变量类比去理解!
如下图所示,定义的整型变量i、指针变量p均在main 函数的栈空间中,通过 malloc 申请的空间会返回一个堆空间的首地址,我们把首地址存入变量p。知道了首地址,就可以通过 strcpy函数往对应的空间存储字符数据。
![](https://i-blog.csdnimg.cn/direct/860f3b0020024ec2867810dd731b138d.png)
既然都是内存空间,为什么还要分栈空间和堆空间呢?栈是计算机系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈操作、出栈操作都有专门的指令执行,这就决定了栈的效率比较高;堆则是C/C++函数库提供的数据结构,它的机制很复杂,例如为了分配一块内存,库函数会按照一定的算法(具体的算法可参考关于数据结构、操作系统的书籍)在堆内存中搜索可用的足够大小的空间,如果没有足够大小的空间(可能由于内存碎片太多),那么就有可能调用系统功能去增加程序数据段的内存空间,这样就有机会分到足够大小的内存,然后返回。显然,堆的效率要比栈低得多。
栈空间由系统自动管理,而堆空间的申请和释放需要自行管理,所以在具体例子中需要通过 free函数释放堆空间,free 函数的头文件及格式为
#include <stdlib.h>
void free(void *ptr);
其传入的参数为 void 类型指针,任何指针均可自动转为 void*类型指针,所以我们把p传递给free 函数时,不需要强制类型转换。p的地址值必须是malloc 当时返回的地址值,不能进行偏移,也就是在malloc和free 之间不能进行p=p+1等改变变量p的操作,原因是申请一段堆内存空间时,内核帮我们记录的是起始地址和大小,所以释放时内核用对应的首地址进行匹配,匹配不上时,进程就会崩溃,如果要偏移进而存储数据,那么可以定义两个指针变量来解决。
01.5.5 栈与堆的差异
先试试偏移p再执行free,看看程序崩溃的效果。
【例】栈空间与堆空间的差异
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//堆和栈的差异
char* print_stack()
{
char c[100]="I am print_stack func";
char *p;
p=c;
puts(p);
return p; //函数空间释放后,函数内所有局部变量消失
}
char *print_malloc()
{
char *p=(char*)malloc(100); //堆空间在整个进程中一直有效,不因为函数结束而消亡
strcpy(p,"I am print malloc func");
puts(p);
return p;
}
int main() {
char *p;
p=print_stack(); //数据放在栈空间
puts(p); //程序崩溃,出现乱码
p=print_malloc(); //数据放在堆空间
puts(p);
free(p); //只有free时,堆空间才会释放
return 0;
}
运行结果
为什么第二次打印会有异常?原因是print_stack()函数中的字符串存放在栈空间中,函数执行结束后,空间会被释放,字符数组c的原有空间已被分配给其他函数使用,因此在调用 print_stack()函数后,print(p=%s\n",p);中的p不能获取栈空间的数据。而 print malloc()函数中的字符串存放在堆空间中,堆空间只有在执行free 操作后才会释放,否则在进程执行过程中会一直有效。
练习题
1.int a;如果我们编写*&a 这样的表达式没有意义,因为其与a是等价的。
A.正确 B.错误
答案:A
解释:*也就是取值运算符,和&也就是取地址运算符,优先级别相同自右向左的方向结合,因此*&a这样的表达式没有意义,与a等价。
2.int a[N]={1,2,3,4,5}; int*p; p-a; 对于这个操作,我们如果进行p=p+1,p的值增大了一个字节。
A.正确 B.错误
答案:B
解释:对于指针变量做加法运算时,每次加1,增加的长度是其基类型的长度,因为基类型是int,
所以p的值增大了4个字节。
3.数组名传递给子函数时,是弱化为指针的。
A.正确 B.错误
答案:A
解释:C语言的子函数形参位置,并没有数组变量的设计,我们把数组名实参传递给子函数时,形参接收到的是数组名内存储的数组的起始地址。