高素质编程师语言课件第八章

PPT

阅读 91 次
下载 0 次
页数 83 页
大小 1.807 MB
2022-11-24 上传

下载文档30.00 元 加入VIP免费下载

此文档由【小橙橙】提供上传，收益归文档提供者，本网站只提供存储服务。若此文档侵犯了您的版权，欢迎进行违规举报或版权认领

可在后台配置第一页与第二页中间广告代码

可在后台配置第二页与第三页中间广告代码

可在后台配置第三页与第四页中间广告代码

还剩10页未读，继续阅读

【这是免费文档，您可以免费阅读】

/ 83

下载文档30.00 元 加入VIP免费下载

TA最新上传

文本内容

【文档说明】高素质编程师语言课件第八章.ppt，共(83)页，1.807 MB，由小橙橙上传

转载请保留链接：https://www.ichengzhen.cn/view-45523.html

以下为本文档部分文字说明：

第八章指针C程序设计中使用指针可以:使程序简洁、紧凑、高效有效地表示复杂的数据结构动态分配内存得到多于一个的函数返回值Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile

right2004-2011AsposePtyLtd.§8.1指针的概念变量与地址程序中:inti;floatk;内存中每个字节有一个编号-----地址…...…...2000200120022005内存02003ik编译或函数调用时为其分配内存单元变量是对程序中数据存储空间的抽象E

120022003指针与指针变量指针：一个变量的地址指针变量：专门存放变量地址的变量叫~2000指针指针变量变量的内容变量的地址指针变量变量变量地址(指针)变量值指向地址存入指针变量Evaluationonly.eat

200420062005整型变量i10变量i_pointer2001200220032000指针变量i_pointer-----指针变量，它的内容是地址量*i_pointer----指针的目标变量，它的内容是数据&i_pointer---指针变量

占用内存的地址200010i_pointer*i_pointer&i_pointerii_pointer&i&(*i_pointer)i*i_pointer*(&i)i_pointer=&i=&(*i_pointer)i=*i_pointer=*(&i)Evaluationonly.eat

ght2004-2011AsposePtyLtd.直接访问与间接访问直接访问：按变量地址存取变量值间接访问：通过存放变量地址的变量去访问变量例i=3;-----直接访问指针变量…...…...2000200420062005整型变量i10变量i_poi

nter20012002200320003例*i_pointer=20;-----间接访问20Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.2.0Cop

11AsposePtyLtd.指针变量…...…...2000200420062005整型变量i10变量i_pointer2001200220032000整型变量k例k=i;--直接访问k=*i_pointer;--间接访问10例k=i;k

指针变量的定义一般形式：[存储类型]数据类型*指针名；3变量i2000i_pointer*i_pointeri*i_pointer&ii_pointeri=3;*i_pointer=33变量i2000i_p

ointer*i_pointeri*i_pointer&ii_pointeri=3;*i_pointer=3合法标识符指针变量本身的存储类型指针的目标变量的数据类型表示定义指针变量不是‘*’运算符例int*p1,*p2;float*q;staticc

har*name;注意：1、int*p1,*p2;与int*p1,p2;2、指针变量名是p1,p2,不是*p1,*p23、指针变量只能指向定义时所规定类型的变量4、指针变量定义后，变量值不确定，应用前必须先赋值Evaluationonly.eatedwithAspose

一致例int*p=&i;inti;例inti;int*p=&i;int*q=p;用已初始化指针变量作初值例main(){inti;staticint*p=&i;..............}()不能用auto变量的地址去初始化static型指针E

p=i;printf(“%d”,*p);}指针变量必须先赋值,再使用…...…...2000200420062005整型变量i10指针变量p200120022003随机Evaluationonly.eated

该单元不作它用表示指针变量值没有意义#defineNULL0int*p=NULL:p=NULL与未对p赋值不同用途:避免指针变量的非法引用在程序中常作为状态比较例int*p;......while(p!=NULL){...…}

void*类型指针表示:void*p;使用时要进行强制类型转换例char*p1;void*p2;p1=(char*)p2;p2=(void*)p1;表示不指定p是指向哪一种类型数据的指针变量Evaluationonly.eatedwithAspo

",a);printf("*pa:%d\n",*pa);printf("&a:%x(hex)\n",&a);printf("pa:%x(hex)\n",pa);printf("&pa:%x(hex)\n",&pa);}运行结果：a:10*pa:10&a:f86(hex)pa:f86(h

输入两个数，并使其从大到小输出main(){int*p1,*p2,*p,a,b;scanf("%d,%d",&a,&b);p1=&a;p2=&b;if(a<b){p=p1;p1=p2;p2=p;}printf("a=%d,b=%d\n",a,b);printf("max=%d,

min=%d\n",*p1,*p2);}运行结果：a=5,b=9max=9,min=5…...…...指针变量p1指针变量p20002008200220042006指针变量p2整型变量b整型变量a520069

intx,inty){inttemp;temp=x;x=y;y=temp;}main(){inta,b;scanf("%d,%d",&a,&b);if(a<b)swap(a,b);printf("\n%

d,%d\n",a,b);}例将数从大到小输出…...…...20002008200A2002200420065变量a变量b(main)9变量temp变量y变量x(swap)55959COPYEvaluationonly.eatedwithAspose.Slidesfor.NET

ght2004-2011AsposePtyLtd.指针变量作为函数参数——地址传递特点：共享内存,“双向”传递swap(intx,inty){inttemp;temp=x;x=y;y=temp;}main(){inta,b;scanf("%

d,%d",&a,&b);if(a<b)swap(a,b);printf("\n%d,%d\n",a,b);}例将数从大到小输出值传递…...…...20002008200A2002200420065变量a变量b(main)9运

p=*p1;*p1=*p2;*p2=p;}main(){inta,b;int*pointer_1,*pointer_2;scanf("%d,%d",&a,&b);pointer_1=&a;pointer_2=&b;if(a<b)swap(pointer_1,poi

nter_2);printf("\n%d,%d\n",a,b);}…...20002008200A200220042006200C200E2010...59整型变量a整型变量b(main)指针pointer_1指针pointer_220002002(swap)指针p

int*p1,int*p2){intp;p=*p1;*p1=*p2;*p2=p;}main(){inta,b;int*pointer_1,*pointer_2;scanf("%d,%d",&a,&b);pointer_1=&a;pointer_2=&b

;if(a<b)swap(pointer_1,pointer_2);printf("\n%d,%d\n",a,b);}…...20002008200A200220042006200C200E2010...59整型变量a整型变量b(main)指针pointer_1指针pointer_

osePtyLtd.swap(int*p1,int*p2){int*p;*p=*p1;*p1=*p2;*p2=*p;}main(){inta,b;int*pointer_1,*pointer_2;scanf("%d,%d",&a,&b);

pointer_1=&a;pointer_2=&b;if(a<b)swap(pointer_1,pointer_2);printf("\n%d,%d\n",a,b);}运行结果：9，9编译警告！结果不对！i

ntx;int*p=&x;x;例将数从大到小输出…...20002008200A200220042006200C200E2010...59整型变量a整型变量b(main)指针pointer_1指针pointer_2200020029920002002COPY(swap)

main(){inta,b;int*pointer_1,*pointer_2;scanf("%d,%d",&a,&b);pointer_1=&a;pointer_2=&b;if(a<b)swap(*pointer_1

,*pointer_2);printf("\n%d,%d\n",a,b);}运行结果：5，9例将数从大到小输出值传递…...20002008200A200220042006200C200E2010...59整型a整型b(main)pointer_1poin

int*p;p=p1;p1=p2;p2=p;}main(){inta,b;int*pointer_1,*pointer_2;scanf("%d,%d",&a,&b);pointer_1=&a;pointer_2=&b;if(a<b)swap(point

er_1,pointer_2);printf("%d,%d",*pointer_1,*pointer_2);}…...20002008200A200220042006200C200E2010...59整型a整型

b(main)pointer_1pointer_22000200220002002COPY(swap)指针p1指针p2指针p****2000地址传递20002002Evaluationonly.eatedwithAspose.Slidesf

osePtyLtd.§8.3指针与数组指向数组元素的指针变量例intarray[10];int*p;p=&array[0];//p=array;或int*p=&array[0];或int*p=array;array[0]array[1]array

址p)p=array;(将数组array首地址p)p=&array[i];(将数组元素地址p)p1=p2;(指针变量p2值p1)不能把一个整数p,也不能把p的值整型变量如inti,*p;p=1000;()i=p;()指针变量与其指向的变量具有相同数据类型Eva

,p-=i等若p1与p2指向同一数组，p1-p2=两指针间元素个数(p1-p2)/dp1+p2无意义例p指向float数，则p+1p+14例p指向int型数组，且p=&a[0];则p+1指向a[

1]例inta[10];int*p=&a[2];p++;*p=1;例inta[10];int*p1=&a[2];int*p2=&a[5];则：p2-p1=3;a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9]a数组pp+1,a+1p+i,a+ip+9,a+

数组元素表示方法a[0]a[1]a[2]a[3]a[9]...aa+9a+1a+2地址元素下标法a[0]a[1]a[2]a[9]a[0]a[1]a[2]a[3]a[9]...pp+9p+1p+2地址元素指针法*p*(p+1)*(p+2)*(p+9)[]变址运算符a[i]*(a+i)a[i]p

in(){inta[5],*pa,i;for(i=0;i<5;i++)a[i]=i+1;pa=a;for(i=0;i<5;i++)printf("*(pa+%d):%d\n",i,*(pa+i));for(i

=0;i<5;i++)printf("*(a+%d):%d\n",i,*(a+i));for(i=0;i<5;i++)printf("pa[%d]:%d\n",i,pa[i]);for(i=0;i<5;i++

)printf("a[%d]:%d\n",i,a[i]);}12345paEvaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.2.0Copyright2

,2,3,4,5,6,7,8,9,10},*p=a,i;数组元素地址的正确表示：（A）&(a+1)（B）a++（C）&p（D）&p[i]数组名是地址常量p++,p--()a++,a--()a+1,*(a+2)()Evaluationon

y);printf(“%d”,a[0]);}输出：56pp58762730123456a例注意指针变量的运算6Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientP

1AsposePtyLtd.main(){inti,*p,a[7];p=a;for(i=0;i<7;i++)scanf("%d",p++);printf("\n");for(i=0;i<7;i++,p++)printf("%d",*p);}例注意指针的当前值p=a;pp58762730

td.数组名作函数参数数组名作函数参数，是地址传递数组名作函数参数，实参与形参的对应关系实参形参数组名指针变量数组名指针变量数组名数组名指针变量指针变量Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.

ght2004-2011AsposePtyLtd.例将数组a中的n个整数按相反顺序存放ij379110675420123456789ijijijji11760594723实参与形参均用数组voidinv(intx[],intn){intt,i,j,

m=(n-1)/2;for(i=0;i<=m;i++){j=n-1-i;t=x[i];x[i]=x[j];x[j]=t;}}main(){inti,a[10]={3,7,9,11,0,6,7,5,4,2};inv(a,10);printf("Thearrayhasbeenrevert

ed:\n");for(i=0;i<10;i++)printf("%d,",a[i]);printf("\n");}m=4Evaluationonly.eatedwithAspose.Slidesfor.NET3.5Clien

t2004-2011AsposePtyLtd.例将数组a中的n个整数按相反顺序存放voidinv(int*x,intn){intt,*p,*i,*j,m=(n-1)/2;i=x;j=x+n-1;p=x+m;for(;i<=p;

i++,j--){t=*i;*i=*j;*j=t;}}main(){inti,a[10]={3,7,9,11,0,6,7,5,4,2};inv(a,10);printf("Thearrayhasbeenr

everted:\n");for(i=0;i<10;i++)printf("%d,",a[i]);printf("\n");}�实参用数组,形参用指针变量37911067542a[0]a[1]a[2]a[3]a[4]a

t*x,intn){intt,*i,*j,*p,m=(n-1)/2;i=x;j=x+n-1;p=x+m;for(;i<=p;i++,j--){t=*i;*i=*j;*j=t;}}main(){inti,a[10],*p=a;for(i=0;i<10;i++,p++)scanf("%d

",p);p=a;inv(p,10);printf("Thearrayhasbeenreverted:\n");for(p=a;p<a+10;p++)printf("%d",*p);}�实参与形参均用指针变量Evaluationonly

=0;i<=m;i++){j=n-1-i;t=x[i];x[i]=x[j];x[j]=t;}}main(){inti,a[10],*p=a;for(i=0;i<10;i++,p++)scanf("%d",p);p=a;inv(p,10);printf("

Thearrayhasbeenreverted:\n");for(p=arr;p<arr+10;p++)printf("%d",*p);}�实参用指针变量,形参用数组Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientPr

]q[i]*(p+i)*(q+i)形参数组实质上是指针变量，即intq[]int*q在定义指针变量（不是形参）时，不能把int*p写成intp[];系统只给p分配能保存一个指针值的内存区(一般2字节）；而给q分配2*10字节的内存区Evalua

y是地址常量（3）array+i是元素array[i]的地址（4）array[i]*(array+i)arrayintarray[10];Evaluationonly.eatedwithAspose.Slidesfor.NET3.5

1)inta[3][4];a[0]a[1]a[2]200020082016200020022008201020162018a[0][0]a[0][1]a[1][0]a[1][1]a[2][0]a[2][1]a[0][2]a[0][3]a[1][2]a[1][3]

a[2][2]a[2][3]基类型行指针与列指针a[0]+1a[1]+1a[2]+1*(a+0)+1*(a+1)+1*(a+2)+1Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.2.0Copyrig

的首地址，即第0行的首地址a+i-----第i行的首地址a[i]*(a+i)------第i行第0列的元素地址a[i]+j*(a+i)+j-----第i行第j列的元素地址*(a[i]+j)*(*(a+i)+j)a[i][j]a+i=&a[i]=a[i]=*(a+i)=&a[i]

[0],值相等，含义不同a+i&a[i],表示第i行首地址，指向行a[i]*(a+i)&a[i][0]，表示第i行第0列元素地址，指向列inta[3][4];a[0]a[1]a[2]200020

082016200020022008201020162018a[0][0]a[0][1]a[1][0]a[1][1]a[2][0]a[2][1]a[0][2]a[0][3]a[1][2]a[1][3]a[2][2]a[2][3]aa+1a+2Evaluationon

[2]a[0][3]a[1][2]a[1][3]a[2][2]a[2][3]二维数组元素表示形式：（1）a[1][2]（2）*(a[1]+2)（3）*(*(a+1)+2)（4）*(&a[0][0]+1*4+2)地址表示：(1)a+1(2)&a

[1][0](3)a[1](4)*(a+1)(5)(int*)(a+1)行指针列指针地址表示：(1)&a[1][2](2)a[1]+2(3)*(a+1)+2(4)&a[0][0]+1*4+2Evaluationon

)第1行第0列元素地址a[1]+2,*(a+1)+2,&a[1][2]第1行第2列元素地址*(a[1]+2),*(*(a+1)+2),a[1][2]第1行第2列元素值200020002008200820

taticinta[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};int*p;for(p=a[0];p<a[0]+12;p++){if((p-a[0])%4==0)printf("\n");printf("%4d",*p);}}p=*a;p=&a[0][0];p=

*(a+0);p=a;p=*a;p=&a[0][0];p=(int*)a;p=a;inta[3][4];a[0][0]a[0][1]a[1][0]a[1][1]a[2][0]a[2][1]a[0][2]

维数组维数];例int(*p)[4];()不能少int(*p)[4]与int*p[4]不同p的值是一维数组的首地址，p是行指针可让p指向二维数组某一行如inta[3][4],(*p)[4]=a;inta[3][4];a[0][0]a[0][1]a[1][0]a[1][1]a[2][0

]a[2][1]a[0][2]a[0][3]a[1][2]a[1][3]a[2][2]a[2][3]aa+1a+2pp+1p+2p[0]+1或*p+1p[1]+2或*(p+1)+2*(*p+1)或(*p)[1]*(*(p+1)+2)一维

维数组指针变量举例main(){staticinta[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};inti,j,(*p)[4];for(p=a,i=0;i<3;i++,p++)for(j=0;j<4;j++

)printf("%d",*(*p+j));printf("\n");}p=a[0];p=*a;p=&a[0][0];p=&a[0];p=a[0];p=*a;p=&a[0][0];p=&a[0];inta[3][4

];a[0][0]a[0][1]a[1][0]a[1][1]a[2][0]a[2][1]a[0][2]a[0][3]a[1][2]a[1][3]a[2][2]a[2][3]pppp[0][j]Evaluationonly.eatedwithAspose.Slidesfor.NET3.5

4-2011AsposePtyLtd.例二维数组与指针运算main(){inta[3][4]={{1,2,3,4},{3,4,5,6},{5,6,7,8}};inti;int(*p)[4]=a,*q=a[0];for(i=0;i<3;i++){if(i==0)(*p)[i+i/2]=

*q+1;elsep++,++q;}for(i=0;i<3;i++)printf("%d,",a[i][i]);printf("%d,%d\n",*((int*)p),*q);}运行结果：2，4，7，5，3123434565678pq2pqpqE

]指针变量int(*q)[4]数组名intx[][4]指针变量int(*q)[4]数组名a数组名a指针变量p1指针变量p1若inta[3][4];int(*p1)[4]=a;int*p2=a[0];指针变量p2指针变

float*p,intn);voidsearch(float(*p)[4],intn);floatscore[3][4]={{65,67,79,60},{80,87,90,81},{90,99,100,98}};average(*score,12);search(

score,2);}voidaverage(float*p,intn){float*p_end,sum=0,aver;p_end=p+n-1;for(;p<=p_end;p++)sum=sum+(*p);aver=sum/n;print

f("average=%5.2f\n",aver);}voidsearch(float(*p)[4],intn){inti;printf("No.%d:\n",n);for(i=0;i<4;i++)p

rintf("%5.2f",*(*(p+n)+i));}列指针行指针函数说明floatp[][4]6552796080879081909910098ppp[n][i]Evaluationonly.eatedw

+){flag=0;for(i=0;i<4;i++)if(*(*(p+j)+i)<60)flag=1;if(flag==1){printf("No.%disfail,hisscoresare:\n",j+1);for(i=0;i<4;i++)pri

ntf("%5.1f",*(*(p+j)+i));printf("\n");}}}main(){voidsearch(float(*p)[4],intn);floatscore[3][4]={{...},{...},{...}};search(score,3);}6552796

与一维数组指针变量的关系如inta[5][10]与int(*p)[10];二维数组名是一个指向有10个元素的一维数组的指针常量p=a+i使p指向二维数组的第i行*(*(p+i)+j)a[i][j]二维数组形参实际上是一维数组指针变量，即intx[][1

0]int(*x)[10]变量定义(不是形参）时两者不等价系统只给p分配能保存一个指针值的内存区(一般2字节）；而给a分配2*5*10字节的内存区Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.2.0Co

pyright2004-2011AsposePtyLtd.Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.2.0Copyri

ght2004-2011AsposePtyLtd.§8.4指针与字符串字符串表示形式用字符数组实现例main(){charstring[]=“IloveChina!”;printf(“%s\n”,string);printf(“%s\n”,string+7);}I

loveChistring[0]string[1]string[2]string[3]string[4]string[5]string[6]string[7]string[8]string[9]stringstring[10]string[11]string[

main(){char*string=“IloveChina!”;printf(“%s\n”,string);string+=7;while(*string){putchar(string[0]);string++;}}Il

oveChistringn!a\0字符指针初始化:把字符串首地址赋给stringchar*string;string=“IloveChina!”;string*string!=0Evaluationonly.eatedwithAspo

eceh\0r.t.\0mtavoidcopy_string(charfrom[],charto[]){inti=0;while(from[i]!='\0'){to[i]=from[i];i++;}to[i]='\0';}main(){chara[]="Iamateacher."

;charb[]="Youareastudent.";printf("string_a=%s\nstring_b=%s\n",a,b);copy_string(a,b);printf("\nstring_a=%s\nst

ring_b=%s\n",a,b);}voidcopy_string(char*from,char*to){for(;*from!='\0';from++,to++)*to=*from;*to='\0';}main(){char*a="Iamateacher.";

char*b="Youareastudent.";printf("string_a=%s\nstring_b=%s\n",a,b);copy_string(a,b);printf("\nstring_a=%s\nstring_b=%s\n",a,b);}Evaluationonly.e

loveChina!”;()str是地址常量；cp是地址变量cp接受键入字符串时,必须先开辟存储空间例charstr[10];scanf(“%s”,str);()而char*cp;scanf(“%

s”,cp);()改为:char*cp,str[10];cp=str;scanf(“%s”,cp);()Evaluationonly.eatedwithAspose.Slidesfor.NET3.5Cli

ht2004-2011AsposePtyLtd.字符串与数组关系字符串用一维字符数组存放字符数组具有一维数组的所有特点数组名是指向数组首地址的地址常量数组元素的引用方法可用指针法和下标法数组名作函数参数是地址传递等区别存储格式：字符串结束标志赋值方

式与初始化输入输出方式：%s%ccharstr[]={“Hello!”};()charstr[]=“Hello!”;()charstr[]={„H‟,„e‟,„l‟,„l‟,„o‟,„!‟};()char*cp=“Hello”;()inta[]={1,2,3,4

,5};()int*p={1,2,3,4,5};()charstr[10],*cp;inta[10],*p;str=“Hello”;()cp=“Hello!”;()a={1,2,3,4,5};()p={1,2,3,4,5};()sca

nf(“%s”,str);printf(“%s”,str);gets(str);puts(str);Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.2.0Copyright20

11AsposePtyLtd.§8.5指针与函数函数指针：函数在编译时被分配的入口地址,用函数名表示max…...指令1指令2函数指针变量赋值:如p=max;函数返回值的数据类型专门存放函数入口地址可指向返回值类型相同的不同函数指向函数的指针变量定义形式：数据类型(*指针变量名)();

如int(*p)();函数指针变量指向的函数必须有函数说明函数调用形式：c=max(a,b);c=(*p)(a,b);c=p(a,b);对函数指针变量pn,p++,p--无意义()不能省int(*p)()与int*p()不同Evaluationonly.eatedwi

rintf("a=%d,b=%d,max=%d\n",a,b,c);}intmax(intx,inty){intz;if(x>y)z=x;elsez=y;return(z);}main(){intmax(int,int),(*p)();inta,b,c

;p=max;scanf("%d,%d",&a,&b);c=(*p)(a,b);printf("a=%d,b=%d,max=%d\n",a,b,c);}intmax(intx,inty){intz;if(

函数指针变量作参数，求最大值、最小值和两数之和voidmain(){inta,b,max(int,int),min(int,int),add(int,int);voidprocess(int,int,int(*fun)());sc

anf("%d,%d",&a,&b);process(a,b,max);process(a,b,min);process(a,b,add);}voidprocess(intx,inty,int(*fun)

()){intresult;result=(*fun)(x,y);printf("%d\n",result);}max(intx,inty){printf(“max=”);return(x>y?x:y);}min(intx,inty){printf(“min=”);re

turn(x<y?x:y);}add(intx,inty){printf(“sum=”);return(x+y);}Evaluationonly.eatedwithAspose.Slidesfor.NET3.5Clie

PtyLtd.§8.6返回指针值的函数函数定义形式：类型标识符*函数名(参数表);例int*f(intx,inty)例指针函数实现：有若干学生成绩，要求输入学生序号后，能输出其全部成绩main(){floatscore[][4]={{60,70,80,90},{56,89,67,88},{

34,78,90,66}};float*search(float(*pointer)[4],intn),*p;inti,m;printf("Enterthenumberofstudent:");scanf("%d",&m);printf("Thesc

oresofNo.%dare:\n",m);p=search(score,m);for(i=0;i<4;i++)printf("%5.2f\t",*(p+i));}float*search(float(*pointer)[4],intn){float*pt;p

t=*(pointer+n);return(pt);}pointerpointer+1347890665689678860708090score数组ppppEvaluationonly.eatedwithAspose.Slidesfor.NET3.

sePtyLtd.例写一个函数，求两个int型变量中居于较大值的变量的地址int*f1(int*x,int*y){if(*x>*y)returnx;elsereturny;}main(){inta=2,b=3;int*p;p=f1(&

a,&b);printf("%d\n",*p);}…...20002008200A20022004200623指针变量y指针变量x(f1)20022000COPY变量a变量b(main)指针变量p**Evaluationonly.eatedwithAspose.Slidesfo

PtyLtd.例写一个函数，求两个int型变量中居于较大值的变量的地址…...…...20002008200A2002200420062变量a变量b(main)3指针变量p**2002int*f3(int*x,int*y){if(*x>*y)returnx;elser

eturny;}main(){inta=2,b=3;int*p;p=f1(&a,&b);printf("%d\n",*p);}Evaluationonly.eatedwithAspose.Slidesf

pyright2004-2011AsposePtyLtd.例写一个函数，求两个int型变量中居于较大值的变量的地址int*f3(intx,inty){if(x>y)return&x;elsereturn&

y;}main(){inta=2,b=3;int*p;p=f3(a,b);printf("%d\n",*p);}…...20002008200A20022004200623变量y变量x(f3)32COPY变量a变量b(main)指针

址作函数返回值…...…...20002008200A2002200420062变量a变量b(main)3指针变量p**200Aint*f3(intx,inty){if(x>y)return&x;elseret

urn&y;}main(){inta=2,b=3;int*p;p=f3(a,b);printf("%d\n",*p);}Evaluationonly.eatedwithAspose.Slidesfor.NE

-2011AsposePtyLtd.§8.7指针数组和多级指针用于处理二维数组或多个字符串指针数组定义：数组中的元素为指针变量定义形式：[存储类型]数据类型*数组名[数组长度说明]；例int*p[4];

指针所指向变量的数据类型指针本身的存储类型区分int*p[4]与int(*p)[4]指针数组赋值与初始化赋值:main(){intb[2][3],*pb[2];pb[0]=b[0];pb[1]=b[1];……..}int*pb[2]pb[0]pb[1]i

ntb[2][3]123246初始化:main(){intb[2][3],*pb[]={b[0],b[1]};……..}int*pb[2]pb[0]pb[1]intb[2][3]123246Evaluationonly.eatedwithAspose.S

"Basic";char*p[4];p[0]=a;p[1]=b;p[2]=c;p[3]=NULL;……..}或:main(){char*p[4];p[0]="Fortran";p[1]="Lisp";p[2]="Basic";p[3]=NULL;……..}初始化:main(){char*p[]={

"Fortran","Lisp","Basic",NULL};……..}Lisp\0Fortran\0Basic\0p[0]p[1]p[2]p[3]0Evaluationonly.eatedwithA

”,“much”,“stronger”,“point”,“bye”};gain\0stronger\0point\0much\0name[0]name[1]name[2]name[3]name[4]bye\0gain\0stronge

r\0point\0much\0bye\0二维数组与指针数组区别：二维数组存储空间固定字符指针数组相当于可变列长的二维数组分配内存单元=数组维数*2+各字符串长度指针数组元素的作用相当于二维数组的行名但指针数组中元素是指针变量二维数组的行名是地址常量Evaluationonly

=b[0];pb[1]=b[1];for(i=0;i<2;i++)for(j=0;j<3;j++,pb[i]++)printf("b[%d][%d]:%2d\n",i,j,*pb[i]);}例用指针数组处理二维数组int

*pb[2]pb[0]pb[1]intb[2][3]b[0][0]*pb[0]b[0][1]*(pb[0]+1)b[0][2]*(pb[0]+2)b[1][0]*pb[1]b[1][1]*(pb[1]+1)b[1][2]*(pb[1]+2)123246Evaluationo

ame[],intn),print(char*name[],intn);char*name[]={"Followme","BASIC","GreatWall","FORTRAN","Computer"};intn=5

;sort(name,n);print(name,n);}voidsort(char*name[],intn){char*temp;inti,j,k;for(i=0;i<n-1;i++){k=i;fo

r(j=i+1;j<n;j++)if(strcmp(name[k],name[j])>0)k=j;if(k!=i){temp=name[i];name[i]=name[k];name[k]=temp;}}}name[0]name[1]name[2]name[3]name[4]name

sort(char*name[],intn),print(char*name[],intn);char*name[]={"Followme","BASIC","GreatWall","FORTRAN","Compute

r"};intn=5;sort(name,n);print(name,n);}voidsort(char*name[],intn){char*temp;inti,j,k;for(i=0;i<n-1;i++){k=i;for(j=i+1;j<n;j++

)if(strcmp(name[k],name[j])>0)k=j;if(k!=i){temp=name[i];name[i]=name[k];name[k]=temp;}}}name[0]name[1]name[2]name[3]name[4]

nameGreatWallFORTRANComputerFollowmeBASICkkjjji=1kEvaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProf

sePtyLtd.例对字符串排序（简单选择排序）main(){voidsort(char*name[],intn),print(char*name[],intn);char*name[]={"Followme","BASIC"

,"GreatWall","FORTRAN","Computer"};intn=5;sort(name,n);print(name,n);}voidsort(char*name[],intn){char*temp;inti,j,k;for(i=0;i<n

-1;i++){k=i;for(j=i+1;j<n;j++)if(strcmp(name[k],name[j])>0)k=j;if(k!=i){temp=name[i];name[i]=name[k];name

[k]=temp;}}}name[0]name[1]name[2]name[3]name[4]nameGreatWallFORTRANComputerFollowmeBASICkkjji=2Evaluationonly.eatedwithAspose.Slidesfor.N

AsposePtyLtd.例对字符串排序（简单选择排序）main(){voidsort(char*name[],intn),print(char*name[],intn);char*name[]={"Followme","BASIC","GreatWall","FORTRAN","Compute

r"};intn=5;sort(name,n);print(name,n);}voidsort(char*name[],intn){char*temp;inti,j,k;for(i=0;i<n-1;i++){k=i;for(j=i+1;j<n;j++)i

f(strcmp(name[k],name[j])>0)k=j;if(k!=i){temp=name[i];name[i]=name[k];name[k]=temp;}}}name[0]name[1]name[2]name[3]name[4]nameGreat

WallFORTRANComputerFollowmeBASICkkji=3Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.2.0Copyright200

{voidsort(char*name[],intn),print(char*name[],intn);char*name[]={"Followme","BASIC","GreatWall","FORTRAN","Comp

uter"};intn=5;sort(name,n);print(name,n);}voidsort(char*name[],intn){char*temp;inti,j,k;for(i=0;i<n-1;i++){k=i;for(j=

i+1;j<n;j++)if(strcmp(name[k],name[j])>0)k=j;if(k!=i){temp=name[i];name[i]=name[k];name[k]=temp;}}}name[0]name[1]name[2]name[3]name[4]nameGrea

1;int*p2;inti=3;p2=&i;p1=&p2;**p1=5;二级指针:指针变量中存放一级指针变量的地址例int*p;inti=3;p=&i;*p=5;&i3P(指针变量)i(整型变量)一级指针单级

i;()//p是二级指针，不能用变量地址为其赋值指针本身的存储类型最终目标变量的数据类型*p是p间接指向对象的地址**p是p间接指向对象的值例inti=3;int*p1;int**p2;p1=&i;p2=&p1;

**p=5;ip1p23&i&p1**p2,*p1*p2多级指针例三级指针int***p;四级指针char****p;Evaluationonly.eatedwithAspose.Slidesfor.NET3.5Client

include<stdio.h>voidswap(int*r,int*s){int*t;t=r;r=s;s=t;}main(){inta=1,b=2,*p,*q;p=&a;q=&b;swap(p,q);printf("%d,%d\n",*p,*q);}20022000COPY指针变量

200A20022004200612变量a变量b(main)指针变量p2000指针变量q2002例一级指针与二级指针#include<stdio.h>voidswap(int*r,int*s){int*t;t=r;r=s;s=t;}main(){inta=1,b=2,*p,*q;p=&

a;q=&b;swap(p,q);printf("%d,%d\n",*p,*q);}输出:1,2Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.2.0

<stdio.h>voidswap(int*r,int*s){int*t;t=r;r=s;s=t;}main(){inta=1,b=2,*p,*q;p=&a;q=&b;swap(p,q);printf("%d,%d\n",*p,*q);}a

swap(int**r,int**s){int*t;t=*r;*r=*s;*s=t;}main(){inta=1,b=2,*p,*q;p=&a;q=&b;swap(&p,&q);printf("%d,%d\

n",*p,*q);}20002008200A20022004200612变量a变量b(main)指针变量p2000指针变量q200220062004COPY二级指针s二级指针r(swap)指针变量t200020022000Evaluationonly.eatedwithAspose.Slides

2,*p,*q;p=&a;q=&b;swap(&p,&q);printf("%d,%d\n",*p,*q);}20002008200A20022004200612变量a变量b(main)指针变量p2000指针变量q20022

nt**r,int**s){int*t;t=*r;*r=*s;*s=t;}main(){inta=1,b=2,*p,*q;p=&a;q=&b;swap(&p,&q);printf("%d,%d\n",*p,*q);}abpqbapqabrspqabrspq输

dmain(){char**p;char*name[]={"hello","good","world","bye",""};p=name+1;printf("%o:%s",*p,*p);p+=2;while(

**p!=NULL)printf("%s\n",*p++);}name[0]name[1]name[2]name[3]name[4]char*name[5]worldbye\0hellogoodnamep运行结果：644:goodbye用*p可输出

地址(%o或%x),也可用它输出字符串(%s)p*(p++)Evaluationonly.eatedwithAspose.Slidesfor.NET3.5ClientProfile5.2.0Copyright

int*q[10]指针数组名是二级指针常量p=q;p+i是q[i]的地址指针数组作形参，int*q[]与int**q完全等价；但作为变量定义两者不同系统只给p分配能保存一个指针值的内存区；而给q分配10块内存区，

：命令名参数1参数2………参数nmain(intargc,char*argv[]){………}命令行参数传递带参数的main函数形式：C:\TC>copy[.exe]source.ctemp.c有3个字符

串参数的命令行命令行中参数个数元素指向命令行参数中各字符串首地址形参名任意命令行实参main(形参)系统自动调用main函数时传递第一个参数:main所在的可执行文件名Evaluationonly.e

in(intargc,char*argv[]){while(argc-->0)printf("%s\n",*argv++);}1.编译、链接test.c，生成可执行文件test.exe2.在DOS状态下运行(test.exe所在路径下）例如：C:\TC>test

[.exe]helloworld!运行结果：helloworld!运行结果：testhelloworld!argv[0]argv[1]argv[2]char*argv[]worldtesthelloarg

);int(*p)();int**p;定义整型变量ip为指向整型数据的指针变量定义含n个元素的整型数组an个指向整型数据的指针变量组成的指针数组pp为指向含n个元素的一维整型数组的指针变量f为返回整型数的函数p为返回指针的函数，该指针指向一个整型数据p为指向函数的

;（3）int*p(int);（4）int(*p)(int);（5）int*(*p)(int);（6）int(*p[3])(int);（7）int*(*p[3])(int);函数指针数组，函数返回int型指针指针数组指向一维数组的指针返回指针的函数指向函数的指针，函数返回int型变量指向函数的

小橙橙

文档分享，欢迎浏览！

文档 25747
被下载 8
被收藏 0

TA的店铺

高素质编程师语言课件第八章

部编版历史中考一轮复习课件全套

专题复习俄国近现代的发展变化课件-人教版

专题04-世界资本主义制度的确立和发展课件

中考系统复习3-中国现代史-1.中华人民共和国的成立和巩固_人教版历史九年级名师课件

中考历史总复习第一编教材知识梳理第11讲中华民族的抗日战争课件

中考历史主题五-中华民族的抗日战争课件

中考历史总复习第二编热点专题速查专题7大国崛起与大国关系三年两次课件

中考历史总复习第二编热点专题速查专题1我国统一多民族国家的形成发展与巩固课件

中考历史专题复习对外关系-教学课件-人教版

中考历史复习专题四大国发展史及重要大国关系课件