c语言程序设计-第8章-指针

第八章指针表示复杂的数据结构动态分配内存有效地使用字符串、数组在调用函数时能得到多个返回值能直接处理内存地址对设计系统软件是很必要的使用指针可以:§8.1地址和指针的概念如果在程序中定义了一个变量,在对程序进行编译时,系统会给这个变量分配内存单元。内存区的每一个字节都有一个编号,这就是"地址"。1、按通过变量名直接找到变量地址，从而存取变量值的方式称为"直接访问"方式printf("%d",i);scanf("%d",&i);k=i+j;例如:2、变量i的地址存放在另一个变量p中，通过变量p获得变量i的地址，再对变量i进行存取变量值的方式称为"间接访问"。假设变量i_pointer用来存放整型变量的地址,可以通过语句:i_pointer=&i;将i的地址(2000)存放到i_pointer中。要存取变量i的值,可以采用间接方式:先根据变量名i_pointer,得到i的地址(2000),然后从2000、2001字节取出i的值(3)。3010我们把这种专门用来存放变量地址的变量称作是指针变量。一个变量的地址称为该变量的"指针"。如,地址2000就是变量i的指针。用来存放另一个变量的地址(指针)的变量,称为“指针变量”。如i_pointer变量。下面给出指针和指针变量的定义§8.2变量的指针和指向变量的指针变量上图中箭头表示"指向"关系,在程序中用"*"符号表示"指向"。*i_pointer代表i_pointer所指向的变量i8.2.1定义一个指针变量定义指针变量的一般形式为基类型*指针变量名;下面都是合法的定义:int*pointer;//pointer是指向int型变量的指针变量char*p,c;//p是指向字符型变量的指针变量,c是字符变量。定义时，如果变量前面没有*号，则变量不是指针变量。int*pointerint*

是类型pointer是变量名使用取地址运算符得到一个变量的地址,将其赋值给指针变量。inti,j,*pointer_1,*pointer_2;pointer_1=&i;pointer_2=&j;于是：pointer_1指向ipointer_2指向j8.2.2指针变量的初始化

&:取地址运算符。#include"stdio.h"voidmain(){inti=5,j=6;

int*i_pointer,*j_pointer;

i_pointer=&i;j_pointer=&j;

printf("i=%d,&i=%d\n",i,&i);printf("i_pointer=%d\n",i_pointer);printf("*i_pointer=%d\n",*i_pointer);

printf("\nj=%d,&j=%d\n",j,&j);printf("j_pointer=%d\n",j_pointer);printf("*j_pointer=%d\n",*j_pointer);}定义指针变量时要注意两点:在定义指针变量时,指针变量名前面的"*",用来标示该变量的类型为指针类型。(2)在定义指针变量时必须指定基类型。

下面的赋值是错误的∶

floata;int*pointer_1;pointer_1=&a;

指针变量只能存放与其基类型一致的变量的地址定义指针变量时要注意两点:指针运算的结果与基类型密切相关例如,若shortint*p,i;p=&i;则p+1表示使指针往后移动2个字节若float*p,i;p=&i;则p+1表示使指针往后移动4个字节#include"stdio.h"voidmain(){charch='a',*ch_pointer=&ch;shortintsint_I=5,*sint_I_pointer=&sint_I;floatfloat_j=6,*float_j_pointer=&float_j;doubledouble_k=4,*double_k_pointer=&double_k;

printf("ch_pointer=%d\n",ch_pointer);printf("ch_pointer+1=%d\n",ch_pointer+1);

printf("\nsint_I_pointer=%d\n",sint_I_pointer);printf("sint_I_pointer+1=%d\n",sint_I_pointer+1);

printf("\nfloat_j_pointer=%d\n",float_j_pointer);printf("float_j_pointer+1=%d\n",float_j_pointer+1);

printf("\ndouble_k_pointer=%d\n",double_k_pointer);printf("double_k_pointer+1=%d\n",double_k_pointer+1);}8.2.2指针变量的引用

指针变量中只能存放指针,不能将一个整数(或任何其他非地址类型的数据)赋给一个指针变量。两个相关运算符:(优先级相同,结合性为自右而左)

&:取地址运算符。*:指针运算符(或称“间接访问”运算符)。取指针变量所指向的变量的值。可理解为：取内容运算&和*为一元运算符，优先级很高。运算时“从右向左”1.&*pointer等价于pointer

等价于

&a

先进行*pointer运算,得到变量a,再执行&运算。2.*&a等价于a等价于*pointer

即先进行&a运算,得到a的地址,再执行*运算在一个表达式中，如果*和&紧密相连在一起时，可以理解为：两个运算相互抵消。若已执行pointer=&a;

则#include"stdio.h"voidmain(){inta=7;int*aPtr;

aPtr=&a;

printf("a的地址&a是：%p,指针aPtr为：%p\n\n",

&a,aPtr);

printf("a的值为：%d,指针指向的值*aPtr：%d\n",

a,*aPtr);

printf("\n如果&和*相连出现，则等价于&和*互相抵消\n"

"&*aPtr=%p,*&aPtr=%p",&*aPtr,*&aPtr);}例8.1通过指针变量访问整型变量&取地址*取内容%p:以16进制数整型格式输出一个内存地址例8.2输入a和b两个整数,按先大后小的顺序输出#include<stdio.h>voidmain(){

inta,b,*p1=&a,*p2=&b,*p;puts("请输入a,b:");scanf("%d%d",&a,&b);printf("a=%d,b=%d\n",*p1,*p2);

if(a<b)

{p=p1;

p1=p2;

p2=p;}

//交换指针p1,p2

printf("max=%d,min=%d\n",*p1,*p2);printf("a=%d,b=%d",a,b);}p1和p2交换之前p1和p2交换之后#include<stdio.h>voidmain(){inta,b,*p1=&a,*p2=&b,temp,*p=&temp;puts("请输入a,b:");scanf("%d%d",&a,&b);

printf("a=%d,b=%d\n",*p1,*p2);

if(a<b){*p=*p1;*p1=*p2;*p2=*p;}//交换*p1,*p2

printf("max=%d,min=%d\n",*p1,*p2);printf("a=%d,b=%d",a,b);}指针与函数指针既然是数据类型,自然可以做函数的参数和返回值的类型8.2.3变量的指针作为函数参数1）地址做为实参，指针为形参#include<stdio.h>intcube(

int*p

)//形参为指针{intcube; cube=*p**p**p; returncube;}voidmain(){ intn=5,cn; cn=cube(

&n

);//实参为n的地址

printf("n=%d,n立方=%d",n,cn);}2）指针做为实参，指针为形参#include<stdio.h>intcube(

int*p

)//形参为指针{ return*p**p**p; }voidmain(){ intn=5,*p=&n,cn; cn=cube(p);//实参为指针pprintf("n=%d,n立方=%d",n,cn);}3）子函数直接修改实参指针所指向的对象#include<stdio.h>voidcube(

int*p1,int*p2

)//形参为指针{ *p2

=*p1**p1**p1;

/*cube函数直接修改

*p2对应的实参指针所指向的对象*/}voidmain(){ intn=5,*p=&n; intcn,

*cnPtr=&cn;

cube(p,cnPtr);//实参为指针p，cnPtrprintf("n=%d,n立方=%d",*p,*cnPtr);}voidswap(int*x,int*y){inttemp;temp=*x;*x=*y;*y=temp;}main(){voidswap(int*x,int*y);inta,b;a=15;b=8;swap(&a,&b);printf("a=%d,b=%d",a,b);}

voidswap(intx,inty){inttemp;temp=x;x=y;y=temp;}main(){voidswap(intx,inty);inta,b;a=15;b=8;swap(a,b);printf("a=%d,b=%d",a,b);}程序1程序2例8.4:编写函数实现两数的互换被调函数实参形参结果有何不同？主调函数简单变量作函数参数图7-3swap函数调用前后参数变化的示意图1581581581515881581515a)调用swap函数(b)执行swap函数c)从swap函数返回tempxy

bmain函数swap函数①②③aaatemptempxxy

ybb主调函数被调函数main(){inta,b;a=15;b=8;swap(a,b);printf("a=%d,b=%d",a,b);}voidswap(intx,inty){inttemp;temp=x;x=y;y=temp;}1515ab实参形参88xyab程序1xyx,y是auto型局部变量，只存在于子函数中主调函数被调函数main(){inta,b;a=15;b=8;swap(&a,&b);printf("a=%d,b=%d",a,b);}voidswap(int*x,int*y){inttemp;temp=*x;*x=*y;*y=temp;}&a&a实参形参&b&bxyab程序2xy15ab8指针变量作函数参数用指针变量作函数参数实现两数互换函数的示意图158815&a&b&a&b15(a)调用swap函数

(b)执行swap函数

a

a

b

b

*x

*x

*y

*y

y

y

x

x

&a

&b

main函数

swap函数temptemp②①③指针做函数参数#include"stdio.h"main(){voidswap(int*x,int*y);inta=15,b=8;printf("执行函数前：&a=%p:a=%d,&b=%p:b=%d\n",&a,a,&b,b);

swap(&a,&b);printf("\n执行函数后：&a=%p:a=%d,&b=%p:b=%d\n",&a,a,&b,b);}voidswap(int*x,int*y){inttemp; printf("\n\t子函数初值：x=%p:*x=%d,y=%p:*y=%d\n",x,*x,y,*y);

temp=*x;*x=*y;*y=temp;printf("\n\t子函数终值：x=%p:*x=%d,y=%p:*y=%d\n",x,*x,y,*y);}指针变量作函数参数实际上是：将实参指针的值传递给形参指针,形参指针与实参指针指向相同的内存单元；改变形参指针所指向的内存单元里的值，实际上就是改变实参指针所指向的内存单元里的值。数组的指针是指数组的起始地址。数组元素的指针是指数组元素的地址。8.3.1指向数组元素的指针定义一个指向数组元素的指针变量,与定义一个指向变量的指针变量的方法相同。8.3数组的指针和指向数组的指针变量例如:inta[10];

/*定义a数组*/int*p;/*定义p为指向整型变量的指针变量*/p=&a[0];/*使p指向a数组的第0号元素*/p=a;/*使p指向a数组的第0号元素*/p=&a[0];就是把a[0]元素的地址赋给指针变量p。定义数组inta[10],数组名为数组的首地址，a=&a[0]p=a等价于p=&a[0]8.3.2通过指针引用数组元素引用一个数组元素,可以用:1.

下标法,如a[i]形式

2.

指针法,如*(a+i)或*(p+i)其中a是数组名,p是指向数组元素的指针变量,其初值p=a。假设有一个a数组,整型,有10个元素。要输出各元素的值有三种方法:#include<stdio.h>voidmain(){inta[3],i; puts("请输入数组：");for(i=0;i<3;i++)scanf("%d",&a[i]);printf("\n");

for(i=0;i<3;i++)printf("%5d",

a[i]);}采用下标法输出数组中的全部元素

#include<stdio.h>#defineN2voidmain(){inta[N],i;for(i=0;i<N;i++)scanf("%d",a+i);printf("\n");

for(i=0;i<N;i++)printf("%d",*(a+i));}(2)通过数组名计算数组元素地址,找出元素的值。(3)用指针变量指向数组元素#include<stdio.h>#defineN3voidmain(){inta[N],i;int*p=a;puts("请输入数组：");for(

i=0;i<N;i++

)scanf("%d",p+i);printf("\n");

for(p=a;p<a+N;p++)printf("%3d",*p);}使用指针变量指向数组元素应注意的问题:1.可改变指针变量的值,不可改变指针常量的值:2.注意指针变量的当前值

设p为指针变量,a为数组名,则

p++

正确

a++

错误

a是数组名,它是数组首地址,它的值在程序运行期间是固定不变的,是常量。#include<stdio.h>#defineN3voidmain(){int*p,i,a[N];

p=a;puts("请输入数组：");for(i=0;i<N;i++)scanf("%d",p++);printf("\n");

for(i=0;i<N;i++,p++)printf("%d",*p);}有人编写出以下程序，是否有错误？问题出在哪里？问题出在在第一个for循环结束后,p已经指向数组最后一个元素的下一个内存单元,这些单元里的值是不确定的。解决办法,在第二个for循环之前加一个赋值语句:p=a;#include<stdio.h>#defineN3voidmain(){int*p,i,a[N];p=a;puts("请输入数组：");for(i=0;

i<N;

i++)scanf("%d",p++);for(i=0,

p=a;

i<N;

i++,p++)printf("%3d",*p);}3.p可以指向数组以后的内存单元,如inta[10];p=&a[10](按*(a+10)处理);

但不会得到预期的结果。应保证指针指向数组中有效的元素。1)

p++:使p指向下一元素。2)*p++:++和*同优先级,自右而左结合。等价于*(p++)，p++：先用p,再加1。即先算*p,再使p=p+1。有inta[10],*p;p=a;<=>for(i=0;i<10;i++,p++)printf("%d",*p);for(i=0;i<10;i++)printf("%d",*p++);3)*++p:先使p=p+1,再取*p。以下程序的执行结果为：#include<stdio.h>voidmain(){int*p,i,a[4]={1,2,3,4};p=a;for(i=0;i<3;i++)printf("%3d",*p++);

puts("");for(i=0,p=a;i<3;i++)printf("%3d",*++p);}4)(*p)++:p所指向的元素值加1,即(a[0])++。5)设p=&a[i],则:*(--p)<=>a[--i],先使p=p-1,再取*p得到a[i-1]。*(p--)<=>a[i--],先取*p得到a[i],再使p-1=>p。*(++p)<=>a[++i],先使p+1=>p,再取*p得到a[i+1]。

设指针变量p指向数组a,即p=a8.3.3用数组名作函数参数例如:

voidmain(){voidfunc(intarr[],intn);intarray[10]

;…f(array,10);…}voidfunc(intarr[]

,intn){…}在编译时是将arr按指针变量来处理的,相当于将函数f的首部写成f(int*arr,intn)当用数组名作为函数参数时,由于数组名代表的是数组首元素地址,因此传递的值是地址,所以要求形参为指针变量。例8.8如下图所示，将数组a中n个整数按相反顺序存放p239数组长度n=10时，正中间的元素下标：m=4，m=(n-1)/2数组长度n=11的情况中间元素下标m=5例8.8将数组a中n个整数按相反顺序存放11m所以:m=(n-1)/2将数组a中n个整数按相反顺序存放的算法：确定数组的中间元素下标

m=(n-1)/2;循环条件：

for(i=0;i<=m;i++)互换规则：

a[i]=a[n-i-1];#include<stdio.h>voidmain(){voidinv(inta[],intn);voidprintArray(inta[],intn);inta[10]={3,7,9,11,0,6,7,5,4,2};

printf("数组初值:\n");

printArray(a,10);

inv(a,10);printf("反序后的数组:\n");

printArray(a,10);}例8.8将数组a中n个整数按相反顺序存放//打印数组函数定义voidprintArray(inta[],intn){ inti; for(i=0;i<n;i++) printf("%4d",a[i]); printf("\n");}//反序存放数组函数定义voidinv(inta[],intn){inti,temp,m; m=(n-1)/2; for(i=0;i<=m;i++){ temp=a[i]; a[i]=a[n-i-1]; a[n-i-1]=temp;}}

#include<stdio.h>voidmain(){voidinv(int*x,intn);voidprintArray(inta[],intn);inta[10]={3,7,9,11,0,6,7,5,4,2};

printf("数组初值:\n");

printArray(a,10);

inv(a,10);printf("反序后的数组:\n");

printArray(a,10);}例8.8修改程序，以指针做为函数形参//打印数组函数定义voidprintArray(inta[],intn){ inti; for(i=0;i<n;i++) printf("%4d",a[i]); printf("\n");}//反序存放数组函数定义voidinv(int*x,intn){ int*i,*j,temp,m; m=(n-1)/2;

for(i=x,j=i+n-1;i<=x+m;i++,j--){ temp=*i;*i=*j; *j=temp;}}形式参数形式上是数组,实际上是指针变量。归纳起来,如果有一个实参数组,想在函数中改变此数组中的元素值,实参与形参的对应关系有以下4种情况:(1)形参和实参都用数组名,如:voidmain()voidf(intx[],intn){inta[10];{……f(a,10);}}(2)实参用数组名,形参用指针变量。如:voidmain()voidf(int*x,intn){inta[10];{……f(a,10);}}(3)实参形参都用指针变量。例如:voidmain()voidf(int*x,intn){inta[10];{…int*p=a;……f(p,10);}}形式参数形式上是数组,实际上是指针变量。(4)实参为指针变量,形参为数组名。如:

voidmain()voidf(intx[],intn){inta[10];{…int*p=a;

…

…f(p,10);}}8.3.4多维数组与指针p245

1.多维数组元素的地址先回顾一下多维数组的性质,可以认为二维数组是"数组的数组",例:shortinta[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};则二维数组a可看成是由3个一维数组所组成的。设二维数组的首行的首地址为1245008,则124500812450241245040#include"stdio.h"#definePNprintf("\n")voidmain(){inta[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};inti,j;for(i=0;i<3;i++){ for(j=0;j<4;j++)printf("&a[%d][%d]=%d\n",i,j,

&a[i][j]

);PN;}}二维数组a可看成是由3个一维数组所组成的#include"stdio.h"#definePNprintf("\n")voidmain(){inta[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};inti,j;for(i=0;i<3;i++){

printf("a[%d]=%d\n",i,a[i]); for(j=0;j<4;j++)printf("&a[%d][%d]=%d\n",i,j,

&a[i][j]

);PN;}}二维数组a可看成是由3个一维数组所组成的,三个一维数组的数组名分别为a[0]，a[1]，a[2]a是由a[0]，a[1]，a[2]组成的一维数组的数组名//修改程序为：#include"stdio.h"voidmain(){inta[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};inti;

printf("a=%d\n",a);for(i=0;i<3;i++){ printf("a[%d]=%d\n",i,a[i]);}}inta[3][4]定义一个二维数组这个二维数组可以看成是由a[0],a[1],a[2]三个元素组成的一维数组。这个一维数组的数组名是a，是指向数组元素的指针，代表一维数组的首地址，值为&a[0]a+n指向数组中的第n个元素a+1=&a[1]a+2=&a[2]#include"stdio.h"voidmain(){inta[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};inti;

for(i=0;i<3;i++){ printf("a+%d=%d,&a[%d]=%d\n",i,a+i,i,&a[i]);}}inta[3][4]定义一个二维数组这个二维数组可以看成是由a[0],a[1],a[2]三个元素组成的一维数组。a[0]实际上是由a[0][0]，a[0][1]，a[0][2]，a[0][3]四个元素构成的一维数组的数组名a[0]是指向数组元素的指针，代表一维数组的首地址，值为&a[0][0]a[0]+n指向数组中的第n个元素a[0]+1=&a[0][1]a[0]+2=&a[0][2]#include"stdio.h"voidmain(){inta[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};inti;

for(i=0;i<3;i++) printf("a[0]+%d=%d,&a[0][%d]=%d\n",i,

a[0]+i,

i,&a[0][i]

);}a[0]+1:对应第0行第1列的地址a[1]+1:对应第1行第1列的地址,a[2]+1:对应第2行第1列的地址如图10.22所示。二维数组名a代表数组a的首元素的地址,数组a的每一个元素都是一个长度为4的一维数组,故a+1:代表下标为1的元素的地址,对应数组名a[1]a+2:代表下标为2的元素的地址,对应数组名a[2]一维数组名a[0]代表数组a[0]的首元素的地址&a[0][0]一维数组名a[1]代表数组a[1]的首元素的地址&a[1][0]一维数组名a[2]代表数组a[2]的首元素的地址,&a[2][0]故#include"stdio.h"voidmain(){inta[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};printf("a=%p\n",a);printf("*a=%p\n",*a);printf("a[0]=%p\n",a[0]);printf("&a[0]=%p\n",&a[0]);printf("&a[0][0]=%p\n\n",&a[0][0]);}a与a[0]的值虽相同,但由于指针类型不同:

a:

二维数组名,指向行a[0];a[0]:一维数组名,指向列元素a[0][0]。故a+1≠a[0]+1对一维数组inta[N]:a[i]表示a数组的第i个元素的值对二维数组inta[N][M]:a[i]是一个一维数组名,是一个地址在行指针前加一个*,行指针就转换为列指针*a=a[0]:指向第0列的指针在列指针前面加&,列指针就成为行指针

&a[0]=a:指向第0行的指针∵a[i]<=>*(a+i)∴a[i]+j<=>*(a+i)+j<=>&a[i][j]∴*(a[i]+j)<=>*(*(a+i)+j)<=>a[i][j]由上可看出:a+1:1代表一行中全部元素所占字节数8a[i]+1:1代表一列元素所占字节数2第i行第j列的元素的地址可表示为:a[i]+j表示形式含义地址a

二维数组名,即0行首地址2000*(a+0),*a,a[0]0行0列元素地址2000a+1,&a[1]1行首地址2008*(a+1),a[1]1行0列元素a[1][0]的地址2008*(a+1)+2,a[1]+2,&a[1][2]1行2列元素a[1][2]的地址2012*(a[1]+2),*(*(a+1)+2),a[1][2]1行2列元素a[1][2]的值元素值为13直接使用二维数组下标#include"stdio.h"voidmain(){shortinta[3][4]={{0,1,2,3},{10,11,12,13},{20,21,22,23}};inti,j;for(i=0;i<3;i++){ printf("\n"); for(j=0;j<4;j++) printf("%p:%d\n",&a[i][j],a[i][j]);}}以一维数组名为指针#include"stdio.h"voidmain(){shortinta[3][4]={{0,1,2,3},{10,11,12,13},{20,21,22,23}};inti,j;for(i=0;i<3;i++){ printf("\n"); for(j=0;j<4;j++) printf("%p:%d\n",a[i]+j,*(a[i]+j));}}以二维数组名为指针#include"stdio.h"voidmain(){shortinta[3][4]={{0,1,2,3},{10,11,12,13},{20,21,22,23}};inti,j;for(i=0;i<3;i++){ printf("\n"); for(j=0;j<4;j++) printf("%p:%d\n",*(a+i)+j,*(*(a+i)+j));}}以下程序是否有误？#include"stdio.h"voidmain(){shortinta[3][4]={{0,1,2,3},{10,11,12,13},{20,21,22,23}};inti,j;for(i=0;i<3;i++){ printf("\n"); for(j=0;j<4;j++) printf("%p:%d\n",(a+i)+j,*(*(a+i)+j));}}2.指向多维数组元素的指针变量(1)指向数组元素的指针变量例用指针变量输出二维数组元素的值

#include"stdio.h"voidmain(){inta[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};inti,j;

int*p=&a[0][0];for(i=0;i<3;i++) {printf("\n"); for(j=0;j<4;j++) printf("%2d",

*(p+i*4+j)); }}

a[i][j]在数组a[m][n]中的相对位置的计算:

i*n+j

/*之前有i行,每行有n个;之前还有j个*/

故a[i][j]的值可表示为*(p+i*n+j)

例如,数组a[3][4]中的a[2][3]的值可表示为:*(p+2*4+3)即*(p+11)如图如果修改程序如下，结果如何？#include"stdio.h"voidmain(){inta[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};inti,j;

int*p=a;for(i=0;i<3;i++) {printf("\n"); for(j=0;j<4;j++) printf("%2d",

*(p+i*4+j)); }}

--------------------Configuration:c11-Win32Debug-------:errorC2440:'initializing':cannotconvertfrom'int[3][4]'to'int*'Typespointedtoareunrelated;conversionrequiresreinterpret_cast,C-stylecastorfunction-stylecast执行cl.exe时出错.c11.exe-1error(s),0warning(s)a与a[0]的值虽相同,但由于指针类型不同:

a:

二维数组名,指向行a[0];a[0]:一维数组名,指向列元素a[0][0]。故a+1≠a[0]+1对一维数组inta[N]:a[i]表示a数组的第i个元素的值对二维数组inta[N][M]:a[i]是一个一维数组名,是一个地址a是行指针，*a=a[0]指向第0列的指针，也就是说，a是指向指针的指针变量。a[0]是列指针，a[0]是指向整型变量的指针变量2.指向多维数组元素的指针变量(1)指向数组元素的指针变量例8.11用指针变量输出二维数组元素的值

#include"stdio.h"voidmain(){int

a[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};inti,j;

int(*p)[4]

=a;for(i=0;i<3;i++) {printf("\n"); for(j=0;j<4;j++) printf("%2d",

*(*(p+i)+j)); }}

(2)指向一维数组的指针变量例8.13输出二维数组任一行任一列元素的值#include"stdio.h"main(){inta[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}};int(*p)[4]=a;inti,j;printf("i(0-2):");scanf("%d",&i);printf("j(0-3):");scanf("%d",&j);printf("a[%d][%d]=%2d",i,j,*(*(p+i)+j));}①inta[4];

//a为数组名,有4个整型元素②

int(*p)[4];

//(*p)为数组名,有4个整型元素这4个元素分别为:

(*p)[0],(*p)[1],(*p)[2],(*p)[3]图8.24(*p)=a[0],(*(p+1))=a[1],(*(p+2))=a[2],(*(p+3))=a[3],对应于a[0][0]…a[0][3],a是二维数组名,故p是行指针,指向二维数组的每一行。∴*(p+i)+j

是a数组第i行第j列元素的地址。即*(*(p+i)+j)

是a[i][j]

的值。对int(*p)[4];的理解:图8.24图8.253.用指向数组的指针作函数参数例8.14有一个班,3个学生,各学4门课,计算总平均分数以及第n个学生的成绩。p2521)用指向数组的指针作函数参数。

2)定义函数average求总平均成绩

3)定义函数search找出并输出第i个学生的成绩。voidaverage

(

float*p,intn

){float*p_end;

floatsum=0,aver;

p_end=p+n-1;

for(;p<=p_end;p++)

sum=sum+(*p);

aver=sum/n;

printf("average=%5.2f\n",aver);}voidsearch(

float(*p)[4],intn

){

inti;

printf("no.%d

:\n",n);

for(i=0;i<4;i++)

printf("%5.2f",*(*(p+n)+i));}#include"stdio.h“voidmain(){voidaverage(float*p,intn);voidsearch(float(*p)[4],intn);floatscore[3][4]={{65,67,70,60},

{80,87,90,81},

{90,99,100,98}};/*求12个分数的平均分*/average(*score,12);/*求序号为2的学生的成绩*/search(score,2);}例8.15在上题基础上,查找有一门以上课程不及格的学生,打印出他们的全部课程的成绩。

#include<stdio.h>voidmain(){void

search(float(*p)[4],intn);/*函数声明*/floatscore[3][4]={{65,57,70,60},{58,87,90,81},{90,99,100,98}};

search(score,3);}voidsearch(float(*p)[4],intn){inti,j,flag;for(j=0;j<n;j++){flag=0;for(i=0;i<4;i++)if(*(*(p+j)+i)<60)

flag=1;if(flag==1){printf("no.%dfails,hisscoresare:\n",j+1);

for(i=0;i<4;i++)printf("%5.1f",*(*(p+j)+i));

printf("\n");

}}}

程序运行结果如下:no.1fails,hisscoresare:65.057.070.060.0no.2fails,hisscoresare∶58.087.090.081.0§8.4字符串与指针8.4.1字符串的表示形式

例8.16定义一个字符数组,对它初始化,

然后输出该字符串

#include<stdio.h>voidmain(){charstring[]="ilovechina！";printf("%s\n",string);}(1)用字符数组存放一个字符串,然后输出该字符串。(2)用字符指针指向一个字符串

可以不定义字符数组,而定义一个字符指针。用字符指针指向字符串中的字符。例8.17定义字符指针#include<stdio.h>voidmain(){char*string="ilovechina！";

printf("%s\n",string);}其中,char*string="ilovechina！";<=>char*string;string="ilovechina！";是把字符串首地址赋给string。不是把字符串"ilovechina！"赋给*string。例8.18将字符串a复制为字符串b

#include<stdio.h>voidmain(){chara[]="iamaboy.",b[20];inti;for(i=0;*(a+i)!='\0';i++)*(b+i)=*(a+i);*(b+i)='\0';printf("stringais:%s\n",a);printf("stringbis:");for(i=0;b[i]!='\0';i++)printf("%c",b[i]);}对字符串中字符的存取,可以用下标方法,也可以用指针方法例8.18用指针变量来处理例8.17问题。p258#include"stdio.h"#include"string.h"voidmain(){chara[]="GuangZhouHEMC.",b[40];char*p1=a,*p2=b;for(;*p1!='\0';p1++,p2++)*p2=*p1;*p2='\0';printf("stringbis:");puts(a);printf("stringbis:");p2=b;

puts(p2);}程序必须保证使p1和p2同步移动。8.4.2字符指针作函数参数#include<stdio.h>voidmain(){voidcopy_string(charfrom[],charto[]);chara[]="";charb[]=".";printf("字符串a=%s\n字符串b=%s\n",a,b);printf("\n拷贝字符串a至b:\n");copy_string(a,b);printf("\n字符串a=%s\n字符串b=%s\n",a,b);}voidcopy_string(charfrom[],charto[]){inti=0;while(from[i]!='\0'){to[i]=from[i];i++;}to[i]='\0';}(1)用字符数组名作参数(2)

用字符指针变量

作参数#include<stdio.h>voidmain(){voidcopy_string(char*from,char*to);chara[]="";charb[]=".";printf("字符串a=%s\n字符串b=%s\n",a,b);printf("\n拷贝字符串a至b:\n");copy_string(a,b);printf("\n字符串a=%s\n字符串b=%s\n",a,b);}voidcopy_string(char*from,char*to){

while(*to++=*from++);}voidcopy_string(char*from,char*to){for(;*from！='\0';from++,to++)*to=*from;*to='\0';}(3)copy_string函数体还可写成如下形式:{while((*to=*from)！='\0'){to++;from++;}}{while((*to++=*from++)！='\0');}{while(*from！='\0‘)*to++=*from++;*to='\0';}while(*to++=*from++);将*from赋给*to,如果赋值后的*to值等于'\0',则循环终止('\0'已赋给*to)

ｗhile语句也可以改用for语句:for(;(*to++=*from++)！='\0';);或for(;*to++=*from++;);也可用指针变量,函数copy_string可写为voidcopy_string(charfrom[],charto[]){char*p1,*p2;p1=from;p2=to;

while((*p2++=*p1++)！='\0');}8.4.3对使用字符指针变量和字符数组的讨论虽然用字符数组和字符指针变量都能实现字符串的存储和运算,但它们二者之间是有区别的,不应混为一谈,主要有以下几点:(1)字符数组由若干个元素组成,每个元素中放一个字符,而字符指针变量只能存放一个字符的地址(字符串第1个字符的地址)。(2)赋值方式。对字符数组除了在定义时,其它时候不能整体赋值。指针可以整体赋值,但所赋的不是字符而是首字符的地址。charstr[14];str="ilovechina！";错误而对字符指针变量,可以采用下面方法赋值:char*a;a="ilovechina！";正确(3)如果定义了一个字符数组,它有确定的值;定义一个字符指针,若未对其赋值,则其值是个不可预料的值。如:charstr[10];scanf(“%s”,str);

//正确。而常有人用下面的方法,目的是想输入一个字符串,虽然一般也能运行,但这种方法是危险的:

char*a;scanf(“%s”,a);//危险，a无初值应当这样:char*a,str[10];a=str;scanf("%s",a);(5)指针变量的值是可以改变的,数组名除了作形参,值不能被改变,是个指针常量。如:例8.20改变指针变量的值#include<stdio.h>voidmain(){char*a="ilovechina！";a=a+7;printf("%s",a);}下面是错的:char

str[]={"ilovechina！"};str=str+7;//错误printf("%s",str);8.5指向函数的指针8.5.1用函数指针变量调用函数

可以用指针变量指向整型变量、字符串、数组,也可以指向一个函数。一个函数在编译时被分配给一个入口地址。这个函数的入口地址就称为函数的指针。#include<stdio.h>void

main(){intmax(int,int);

inta,b,c;

scanf("%d,%d",&a,&b);c=max(a,b);

printf("a=%d,b=%d,max=%d",a,b,c);}intmax(intx,inty){returnx>y?x:y;}例：8.22求两数中的大数p267int(*p)(int,int);p=max;c=(*p)(a,b);int(*p)()——p是指向的函数的指针变量,函数的返回值为整型。int*p()——p是函数名,函数的返回值是指向整型值的指针。故*p两侧的括弧不可省略,表示p先与*结合,是指针变量,然后再与后面的()结合,表示此指针变量指向函数,这个函数值(即函数返回的值)是整型的。#include<stdio.h>voidmain(){intmax(int,int);/*函数声明*/intmin(int,int);/*函数声明*/intadd(int,int);/*函数声明*/voidprocess(int,int,int(*fun)());/*函数声明*/

inta,b;

printf("enterab:");scanf("%d%d",&a,&b);

printf("max=");process(a,b,max);

printf(“min=”);

process(a,b,min);

printff(“sum=”);

process(a,b,add);}8.5.2用指向函数的指针作函数参数例8.23设一个函数process,在调用它的时候,每次实现不同的功能。输入a和b两个数,第一次调用process时找出a和b中大者,第二次找出其中小者,第三次求a与b之和。

intmax(intx,inty)/*函数定义*/{returnx>y?x:y);}intmin(intx,inty)/*函数定义*/

{returnx>y?y:x);}intadd(intx,inty)/*函数定义*/{returnx+y;}voidprocess(intx,inty,int(*fun)(int,int)){printf("%d\n",(*fun)(x,y););}8.6返回指针值的函数一个函数可以带回一个整型值、字符值、实型值等,也可以带回指针型的数据,即地址。其概念与以前类似,只是带回的值的类型是指针类型而已。这种带回指针值的函数,一般定义形式为类型名*函数名(参数表列);例如:int

*a(intx,inty);例8.24有若干个学生的成绩(每个学生有4门课程),要求在用户输入学生序号以后,能输出该学生的全部成绩。用指针函数来实现。#include<stdio.h>voidmain(){floatscore[][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};float*search(float(*pointer)[4],intn);float*p;inti,m;printf("enterthenumberofstudent:");scanf("%d",&m);printf("thescoresofno.%dare:\n",m);p=search(score,m);for(i=0;i<4;i++)printf("%5.2f\t",*(p+i));}float*search(float(*point)[4],intn){float*pt;pt=*(point+n);return(pt);}8.7指针数组和指向指针的指针8.7.1指针数组的概念一个数组,若其元素均为指针类型数据,称为指针数组,也就是说,指针数组中的每一个元素都相当于一个指针变量。一维指针数组的定义形式为类型名数组名[数组长