C语言学习笔记之(指针)
一、指针的概念
如,4G内存中每个字节的编号(以十六进制表示)可以如图所示,每个方框表示一个字节,方框上面的数字即为十六进制表示的字节编号。我们将内存中字节的编号称为地址或指针。

访问变量的方式可分为两种,一种是“直接访问”方式,另一种是“间接访问”方式。
按变量名访问的方式称为“直接访问”方式。例如,图所示即为直接访问方式,通过变量名a直接赋值,由于变量名与变量的地址一一对应,因此,直接将数值1放到变量a的存储单元中。

如果将变量a的地址存放在另一变量中,然后通过该变量来找到变量a的地址,从而访问变量a,这就是“间接访问”方式。例如,图所示即为间接访问方式,先找到存放变量a地址的变量p,从其中得到变量a的地址(2000),从而找到变量a的存储单元,然后对它进行存取访问。这就好比要取抽屉a中的东西,需要先用抽屉p的钥匙打开抽屉p,从抽屉p中取出抽屉a的钥匙,再打开抽屉a。

二、指针变量
1.格式
指针变量与一般变量一样,必须“先定义后使用”。定义一个指针变量需要解决两个问题:一是说明指针变量的名字,二是说明指针变量指向变量的数据类型。定义指针变量的一般形式为:
类型说明符 *指针变量名1,*指针变量名2…;
例如:
int *p1; /*定义指向整型变量的指针变量p1*/
char *p2,*p3; /*定义指向字符型变量的指针变量p2和p3*/
其他类型的变量允许和指针变量在同一个语句中定义,例如:
int m,*p; /*定义2个变量,其中m是整型变量,p是指向整型变量的指针变量*/
- 在定义时,指针变量名前的“*”表示该变量的类型是指针型变量,不能省略。
- 指针变量定义中的“数据类型”是指针指向的目标数据的类型。读者可能会提出,既然指针变量是存放地址的,那么为什么要指定数据类型呢?我们知道,不同类型的数据在内存中所占的字节数和存放方式是不一样的。例如,字符型数据占1个字节,整型数据占4个字节。因此,如果想通过指针引用一个变量,只知道地址(如2000)是不够的,因为无法判断是从地址为2000的一个字节中取出字符型数据,还是从2000到2003四个字节中取出整型数据。
可以在定义指针变量的同时为其赋初值,即指针变量的初始化。由于指针变量是指针类型,因此,所赋初值应是一个地址值。其一般格式为:
类型说明符 *指针变量名1=地址1,*指针变量名2=地址2…;
例如:
int i;
int *p=&i; /*定义指针变量p指向整型变量i*/
表示地址的形式可以是“&变量名”“数组名”“其他指针变量”等。例如:
char s[20];
char *str=s; /*定义指针变量str指向字符数组s的首地址*/
2.给指针变量赋值
在程序执行过程中,可以使用赋值语句为指针变量赋值,一般格式为:
指针变量=地址;
例如:
int a=20,b=30,*p1,*p2;
p1=&a; /*把变量a的地址赋给指针变量p1*/
p2=&b; /*把变量b的地址赋给指针变量p2*/
定义了两个整型变量a和b,a初值为20,b初值为30;定义了指针变量p1指向变量a,指针变量p2指向变量b,其相互之间的关系如左图所示。
指针变量和一般变量一样,存放在它们之中的值是可以改变的,也就是说,可以改变它们的指向,例如,执行表达式语句“p2=p1;”,意思是p2与p1指向同一对象a,此时*p2就等价于a,而不是b,如右图所示。


3.引用指针变量指向的变量
如果在上述定义语句后面执行表达式语句“*p2=*p1;”,即:
int a=20,b=30,*p1,*p2;
p1=&a; /*把变量a的地址赋给指针变量p1*/
p2=&b; /*把变量b的地址赋给指针变量p2*/
*p2=*p1; /*引用指针变量指向的变量*/
则表示把p1指向的内容赋给p2所指的区域,即等价于“b=a;”,如图所示。

4.引用指针变量的值
用十六进制形式输出指针变量p的值,即输出a的地址,可以用如下语句实现。
int a;
int *p=&a;
printf("%x",p);
例子:有下列代码,试分析输出结果。
#include<stdio.h>
int main()
{
int x=10,*p,y;
p=&x; /*取变量x的地址赋给指针变量p*/
y=*p; /*将*p的值赋给y*/
printf("x=%d,*p=%d,y=%d\n",x,*p,y); /*输出x,*p和y的值*/
printf("&x=%x,p=%x,&y=%x\n",&x,p,&y); /*输出x和y的地址以及指针p的值*/
return 0;
}
此例中定义了三个变量,x和y为整型变量,p为指针变量。x的初值为10,让p去指向x,*p表示取指针变量p所指存储单元的内容,即变量x的值,因此,*p和y也等于10。p为指针变量且指向x,因此,p即为x的地址;y和x是不同的变量,因此,它们所占的存储空间不同,即地址不同。
5.空指针
不指向任何对象的指针即为空指针,表示该指针没有指向任何内存单元。构造空指针有下面两种方法。
(1)赋0值。例如:
int *p=0;
除0之外,一般不把其他整数作为初值赋给指针变量。程序运行期间,变量的地址是由计算机分配的,当用一个整数为一个指针变量赋初值后,可能会造成难以预料的后果。
(2)赋NULL值,NULL的值等于0,两者等价。例如:
int *p=NULL;
空指针常用来初始化指针,避免野指针的出现。
对指针变量赋0值和不赋值是不同的。指针变量未赋值时,可以是任意值,是不能使用的,否则将造成意外错误。而指针变量赋0值后,则可以使用,只是它不指向具体的变量。
C语言规定,指针变量也可以定义为void型,例如:
void *p;
这里p仍然是一个指针变量,有自己的内存空间。但是不指定p指向哪种类型的变量。在这种情况下,应该注意:
(1)任何指针都可以赋值给void指针。例如:
int x=10;
int *q=&x;
p=q; /*不需要进行强制类型转换*/
(2)使用void指针时必须对其进行强制类型转换,将void指针转换成它所指向单元的实际类型,然后才可以使用。因此,void指针赋值给其他类型的指针时要进行强制类型转换。例如:
int *t=(int*)p; /*需要进行强制类型转换*/
printf("*p=%d",*(int*)p); /*输出p指向的存储单元内容*/
指针是内存单元的地址,指针变量就是存放指针的变量。不同数据类型在内存中所占内存单元的大小是不一样的,但是地址却是一样的,即使用该数据在内存单元中的首地址。因此,用void指针来存放这个首地址与数据类型无关。但是,当要使用这个数据时,通过指针访问内存单元,系统不仅需要知道内存单元的首地址,而且还要知道这个数据在内存中所占的存储单元的大小,因此,在使用void指针时必须对指针进行强制类型转换。
三、指针与数组
1.定义格式
从第7章中我们了解到,定义完一个一维数组后,每个数组元素就相当于一个变量。既然指针变量可以指向一般的变量,那么当然也可以指向数组中的元素。例如:
int a[5]={1,2,3,4,5},*p;
p=&a[0]; //或者p=a
以上代码的功能是定义一个一维数组和一个指针变量p,使指针变量p指向数组a的第0号元素(即第1个元素),如图所示。

2.数组中的指针运算
加减一个整数
对于指向数组的指针变量,可以加上或减去一个整数n。例如,设p是指向数组a的指针变量,则p+n,p-n,p++,++p,p--,--p都是合法的。
指针变量加或减一个整数n的意义是:把指针指向的当前位置(指向某数组元素)向前或向后移动n个位置。这里加减的单位不是以字节为单位,而是以指向的数据类型所占用的字节数为单位。例如,在Visual C++环境下,int变量占4个字节,double型变量占8个字节。因此,如果p指向整型数组,p+n表示的实际地址为“p+4*n”。
例子:分析以下程序
#include<stdio.h>
int main()
{ int a[5]={1,2,3,4,5};
int *p=a;
printf("a is:%X,a+1 is:%X\n",a,a+1);
printf("p is:%X,p+1 is:%X\n",p,p+1);
printf("*a is:%d,*(a+1) is:%d\n",*a,*(a+1));
printf("*p is:%d,*(p+1) is:%d\n",*p,*(p+1));
return 0;
}
此例中p的初值为a,即&a[0],则p+n和a+n就是数组元素a[n]的地址,或者说,它们指向数组a序号为n的元素,如图所示。这里需要注意的是:a代表数组首元素的地址,a+1也是地址,它的计算方法同p+1,即它的实际地址为a+14。(p+n)或*(a+n)是p+n或a+n所指向的数组元素,即a[n]。例如,(p+1)或(a+1)就是a[1]。

两指针变量相减
如果两个指针变量指向同一数组,则两个指针变量相减所得之差就是两个指针所指数组元素之间相差的元素个数。实际上是两个指针值(地址)相减之差再除以该数组元素的长度(字节数)。例如,p1和p2是指向同一整型数组的两个指针变量,设p1的值为2008H,p2的值为2000H,而整型数组每个元素占4个字节,则p1-p2的结果为(2008H-2000H)/4=2,表示p1和p2之间相差2个元素。
例子:编写程序求字符串的长度,要求使用指针变量。
#include<stdio.h>
int main()
{
char str[50],*p=str; /*定义字符数组str和指针变量p指向数组str*/
printf("Enter string:"); /*输出提示符*/
gets(str); /*输入字符串*/
while(*p) /*p不为'\0'时循环*/
p++; /*找到串结束标记'\0',退出循环时p指向'\0'*/
printf("String length=%d\n",p-str); /*利用指针减法运算求出字符串长度*/
return 0;
}
3.通过指针引用数组元素
引用一个数组元素有两种方法。
(1)下标法,即a[i]的形式。
(2)指针法,如*(a+i)或*(p+i)。其中,a是数组名,p是指向数组元素的指针变量,其初值p=a。指向数组的指针变量也可以带下标,如p[i]与*(p+i)等价。
例子:分析下面程序运行结果。
#include <stdio.h>
int main()
{
int a[5],*p,i;
for(i=0;i<5;i++)
a[i]=i+1;
p=a;
for(i=0;i<5;i++)
printf("*(p+%d):%d\t",i,*(p+i));
for(i=0;i<5;i++)
printf("*(a+%d):%d\t",i,*(a+i));
for(i=0;i<5;i++)
printf("p[%d]:%d\t",i,p[i]);
printf("\n");
for(i=0;i<5;i++)
printf("a[%d]:%d\t",i,a[i]);
printf("\n");
return 0;
}
从程序运行结果中可以得出,(p+i),(a+i),p[i]和a[i]输出的结果都是相同的。
4.指针与二维数组的元素地址
格式
假设定义一个4行3列的二维数组,例如:
int a[4][3];
二维数组在逻辑上是由行和列组成的,因此,对二维数组可以将其分为3层来理解,如图所示。第1层将数组a看作一个变量;第2层将二维数组a看作一个一维数组,由a[0],a[1],a[2]和a[3]这4个元素组成;第3层将第2层中的每个数组元素看作一个单独的数组。

在第1层中将数组a作为一个变量,该变量的地址为&a,变量长度为sizeof(a)。
在第3层中,第2层中的每个元素又由3个元素构成。例如,a[0]又由a[0][0],a[0][1]和a[0][2]这3个元素构成。当将a[0]作为一个数组名时,该数组的首地址也就保存在a[0]中(这里a[0]作为一个整体,看作数组名,不是一个数组的元素),不用取地址运算符&,直接输出a[0]的值就可得到数组的首地址。
例子1:分析下面程序运行结果。
#include <stdio.h>
int main()
{
int a[4][3]; /*定义二维数组*/
printf("变量a的地址:%d\n",&a); /*输出a的地址*/
printf("变量a的长度:%d\n",sizeof(a)); /*输出a所占的地址空间*/
return 0;
}
从程序运行结果可以看出,使用&运算符可取得数组名的地址(不同的计算机得到的地址值可能不同)。数组a的长度为元素数量乘以每个元素占用的字节,4行3列共12个元素,每个元素占用4个字节,所以变量a占用48个字节。
在第2层中,将数组a看作为一维数组,它有4个元素a[0],a[1],a[2]和a[3]。数组的首地址为a或&a[0](第一个元素的地址也是首地址)。使用sizeof(a[0])可得到数组元素的长度。
例子2:分析下面程序运行结果。
#include <stdio.h>
int main()
{
int a[4][3],i;
printf("数组a的首地址:%d\n",a); /*输出数组首地址*/
for(i=0;i<4;i++) /*循环输出数组元素地址*/
{
printf("数组a第%d个元素的地址:%d\n",i+1,&a[i]);
}
printf("数组元素a[0]的长度:%d\n",sizeof(a[0])); /*输出数组元素的长度*/
return 0;
}
以上程序将数组a看作一个一维数组,由4个元素组成。首先输出数组首地址。然后,循环输出4个数组元素的地址,从执行结果可以看出,数组首地址和第一个元素的地址相同,而每个数组元素的地址相差为12,表示每个数组元素的长度为12。最后,程序使用sizeof(a[0])证实数组元素a[0]的长度的确为12。
从以上结果可看出,将二维数组a作为一维数组看待时,其每个元素的长度就是二维数组中一行元素的长度之和。
二维数组中关于指针的表示形式
| 表示形式 | 含 义 |
|---|---|
| &a | 二维数组a的地址 |
| a | 二维数组名,指向一维数组a[0],即0行首地址 |
| a[0],*(a+0),*a | 0行0列元素地址 |
| &a[i],a+i | i行首地址 |
| a[i],*(a+i) | i行0列元素a[i][0]的地址 |
| a[i]+j,*(a+i)+j,&a[i][j] | i行j列元素a[i][j]的地址 |
| (a[i]+j),(*(a+i)+j),a[i][j] | i行j列元素a[i][j]的值 |
5.指针指向数组元素的指针变量
格式
可以用指针变量指向二维数组的元素,若有:
int a[4][3],*p;
p=&a[0][0];
则二维数组a的数据元素在内存中存储顺序、地址及指针变量p的关系如图所示。

从图中,我们可以看出指针和二维数组元素的对应关系。清楚了两者之间的关系,就能用指针处理二维数组了。若有:
int a[M][N];
p=a[0];
对于数组a中的任一元素a[i][j],指针的一般形式为:p+i*N+j;同样,a[i][j]也可以使用指针下标法表示:p[i*N+j]。
例子:求二维数组元素的最大值
#include <stdio.h>
int main()
{
int a[4][3]={{2,12,5},{55,7,98},{10,36,6},{78,42,1}}; /*初始化二维数组*/
int *p=a[0]; /*定义指针变量p指向a[0]*/
int max=*p; /*定义变量max用来存储最大值,初始化为*p*/
while(p<a[0]+12) /*当p<a[0]+12时循环*/
{
if(*p>max) /*当*p大于max时,将*p的值赋给max*/
max=*p;
p++; /*p指向下一个数组元素*/
}
printf("MAX=%d\n",max); /*输出max的值*/
return 0;
}
p是一个int型指针变量;p=a[0]是设置数组的首元素地址为指针初值;max=*p表示将数组的首元素值a[0][0]作为最大值初值;p<a[0]+12表示将指针的变化范围限制在12个元素范围内;p++使得每比较一个元素后,指针后移一个元素位置。
6.指向一维数组的指针变量
我们还可以定义指针变量p指向一个包含N个元素的一维数组。这时,如果p先指向a[0](即p=&a[0]),则p+1不是指向a[0][1],而是指向a[1],p的增值以一维数组的长度为单位,如图所示。

图中,指针p指向的数据类型应该是一个具有3个int元素的数组。因此,应使用以下方式定义该指针变量:
int (*p)[3];
这种方式称为数组指针,即定义的变量是一个指针,其指向类型是一个数组。
例子:求二维数组元素的最大值,并确定最大值元素所在的行和列。
#include <stdio.h>
int main()
{
int a[4][3]={{2,12,5},{55,7,98},{10,36,6},{78,42,1}}; /*初始化二维数组*/
int max,i,j,row,col; /*定义变量*/
int (*p)[3]; /*定义指向一维数组的指针变量*/
p=a; /*p指向二维数组的0行*/
max=a[0][0]; /*max的初始值为a[0][0]*/
row=col=0; /*行号和列号初始值为0*/
for(i=0;i<4;i++) /*外循环控制行*/
for(j=0;j<3;j++) /*内循环控制列*/
if(*(*(p+i)+j)>max) /*如果a[i][j]大于max*/
{
max=*(*(p+i)+j); /*将其值赋给max*/
row=i; /*row为行号*/
col=j; /*col为列号*/
}
printf("MAX=a[%d][%d]=%d\n",row,col,max); /*输出最大值及其位置*/
return 0;
}
该程序中使用双重循环遍历二维数组元素。在程序中,使用*((p+i)+j)的方式指向二维数组的某一个元素。在这里(p+i)得到的是二维数组行的地址,相当于a[i](注意是一个内存地址值)。接着执行*(p+i)+j,相当于a[i]+j,也是一个地址值,表示第i行首地址加上j个元素的位置。最后使用*(*(p+i)+j)即可得到第i行第j列的元素值,相当于a[i][j]。
7.指针与字符串
用字符数组存放一个字符串,可以通过数组名和下标引用字符串中的一个字符,也可以通过数组名和格式声明“%s”输出该字符串。例如:
char str[30]="C language!"; /*定义字符数组str*/
printf(“%c\n”,str[3]); /*用%c格式声明输出str[3]*/
printf(“%s\n”, str); /*用%s格式声明输出str*/
可以把字符数组的首地址赋给一个指针变量,那么这个指针变量则指向这个字符数组,使用该指针变量可以完成对字符数组的操作。此外,我们还可以利用字符串常量对字符指针进行初始化。例如:
char *str="C language!"; /*定义字符指针变量str并初始化*/
此时,字符指针指向的是一个字符串常量的首地址,即指向字符串的首地址。
例子:字符串a和b,编写程序,使用指针将字符串b连接到字符串a的后面。
#include <stdio.h>
int main()
{
char a[50],b[30]; /*定义两个字符数组a和b*/
char *str1,*str2; /*定义两个指针变量*/
printf("Enter string 1:");
gets(a); /*输入字符数组a*/
printf("Enter string 2:");
gets(b); /*输入字符数组b*/
str1=a; /*指针变量str1指向数组a的第一个元素*/
str2=b; /*指针变量str2指向数组b的第一个元素*/
while (*str1!='\0')
str1++; /*找到数组a的结束标记*/
while (*str1++=*str2++); /*将str2连接到str1的后面*/
printf("a+b=%s\n",a); /*输出连接后的数组a*/
}
这里要注意字符指针与字符数组之间的区别。例如,有下面语句:
char *str="C language!";
char string[30]="This is a string.";
str是一个变量,可以改变str使它指向不同的字符串,但不能改变str所指向的字符串常量的值。string是一个数组,可以改变数组中保存的内容。
C语言学习笔记之(指针)
https://www.wsjj.top/archives/c15
评论