第08章-指针-课件

第08章指针

本章主要指针的概念、运算、使用、各种类型的指针、指针数组、类型表达式与复杂类型声明，还讨论了与动态存储分配的相关操作。内容摘要2重点讲解8.1指针的概念与指针的使用8.2

指针运算

8.3指针作为函数的参数8.4数组的指针表示8.5指针数组8.6

带参数的main函数8.7

指针函数8.8函数的指针8.9指向数组的指针（见教材第11章）8.10用typedef定义类型表达式8.11复杂说明的解释8.12复杂说明的应用小结38.1.1

指针概念目录8.1指针的概念与指针的使用

在计算机高级语言中，存储数据的内存单元称为变量，并使用变量名引用之。变量的占用内存的大小和存储数据的格式，是由数据类型确定的。

内存单元之地址称为指针，存储指针的内存单元称为指针变量。intx;floaty;charz;xyz&x&y&zintx;xp&x指针变量如何声明？??int型地址float型地址char型地址4

在指针变量说明语句的一般形式如下：数据类型*标识符1[=初值1][,*标识符2[=初值2],…,*标识符n[=初值n]];其中，*为指针类型符；数据类型为指针所指存储单元之类型，亦称为指针类型，标识符i为指针变量名；初值i为指针类型表达式。int*float*char*8.1.2

指针的声明C语言提供指针数据类型，*为指针类型符，用于声明存储指针的内存单元即指针变量。intfloatcharintx;xp&xint*p=&x;int型地址float型地址char型地址5

根据指向变量之数据类型，指针类型可划分为不同数据类型。char

*int*float*double*longdouble*signedchar*unsignedchar*signedint*unsignedint

*signedlongint*signedshortint*signedint*unsignedlongint*unsignedshortint*unsignedint*整型类型指针浮点类型指针字符类型指针void*6例8.3

解释以下复杂声明的含义。（1）int（*p1）[3]；p1是指向3个元素的整型数组的指针。（2）double*p2[5]；p2是指针数组。（3）char（*fp）(int,int)fp是一个函数指针，所指向的函数有2个整型形参，返回类型char。（4）int*pf（float）pf是指针函数。（5）int（*fp_ary[2]）(char*,char*)fp_ary是一个函数指针数组，该数组的每一个下标变量都是函数指针。78.1.3

指针的使用C语言提供单目运算*为指针指向的内存单元即变量之引用，提供表达方式。单目*运算的一般形式是：*右操作数其中，右操作数为指针表达式，运算结果为右操作数－－指针所指内存单元即变量之名称。intx;xp&xint*p=&x;*P变量x之“别名”x=1;x=x+1;x++;*p=1;*p=*p+1;(*p)++;8大家学习辛苦了，还是要坚持继续保持安静9intx,*p=&x;8.2指针运算目录8.2.1

指针的算术运算

指针类型的算术运算限于加法＋和和减法－，因为其它算术运算无意义。指针运算的一般形式是：⑴表达式1±表达式2

或⑵表达式1-表达式3其中，表达式1为指针表达式；表达式2为整整表达式(≥0)；表达式3为整型或指针表达式(≥0)

；⑴式为指针类型，值为表达式1±表达式2×sizeof(表达式1)；⑵式为整型类型，值为(表达式1-表达式3)÷sizeof(表达式1)

。xp&x<512>*p……p

-1值：<510>p

+1值：<514>*(p-1)*(p+1)(p+1)-(p-1)值：2108.2.2

指针的赋值运算和关系运算

指针赋值的一般形式是：表达式1＝表达式2其中，表达式1为左值表达式；表达式2为指针表达式，运算结果值和类型与表达式1一致

。inta[8]={1,2,3,4,5,6,7,8},*p=&a[0],*q;paqq=p+3*p*q

指针类型可以进行<、<=、>、>=、==和!=关系运算，运算结果为逻辑类型。11

不同基本类型指针之间的赋值运算，必须使用类型强制。利用指针的赋值运算以及类型强制可以实现一些特殊操作。#include"stdio.h"voidmain(void){longx=0x1234ABCD,k;char*p=(char*)&x;/*类型强制，p为字符指针*/charup_half,low_half;/*up_half存高4位，low_half存低4位*/for(k=0;k<4;k++){low_half=(*p)&0x0f;/*取低4位*/if(low_half<10)low_half|=’0’;/*低4位转换成ASCII码’0’-’9’*/elselow_half=(low_half-10)+’A’;/*低4位转换成ASCII码’A’-’F’*/up_half=(*p>>4)&0x0f;/*取高4位*/if(up_half<10)up_half|='0';/*高4位转换成ASCII码'0'-'9'*/elseup_half=(up_half-10)+'A';/*高4位转换成ASCII码'A'-'F'*/p++;/*指向整型数x下一个字节*/printf("%c%c",up_half,low_half);}}

例8.11试从占

4个字节的长整型数之低字节开始，依次取出其每个字节的高

4

位和低

4

位并以ASCII码的形式进行显示。CDAB3412_128.3指针作为函数的参数目录

指针作为函数的参数是指数据类型为指针的函数参数，称为指针参数。指针参数作用是实现子程序之间数据的双向交换。8.3.1

形参指针对实参的影响

例8.12被调用函数中对形参的修改无法影响调用函数中实参变量的值举例。#include"stdio.h"voidsu,intv);voidmain(void){intx,y;printf("inputtwointegersforxandyplease!\n");scanf("%d%d",&x,&y);printf("infunctionmain,beforesandy=%d\n",x,y);s);printf("infunctionmain,aftersandy=%d\n",x,y);}voidsu,intv){intt;printf("infunctionswap,beforesandv=%d\n",u,v);t=u;u=v;v=t;printf("infunctionswap,aftersandv=%d\n",u,v);}13main#include"stdio.h"voidsu,intv);voidmain(void){intx,y;printf("inputtwointegersforxandyplease!\n");scanf("%d%d",&x,&y);printf("infunctionmain,beforesandy=%d\n",x,y);swap(x,y);printf("infunctionmain,aftersandy=%d\n",x,y);}voidswap(intu,int

v){intt;printf("infunctionswap,beforesandv=%d\n",u,v);t=u;u=v;v=t;printf("infunctionswap,aftersandv=%d\n",u,v);}xyswapuvt1020↙1020

…x=10andy=201020

…u=10andv=20201010

…u=20andv=20

…x=10andy=2014main#include"stdio.h"voids*u,int*v);voidmain(void){intx,y;printf("inputtwointegersforxandyplease!\n");scanf("%d%d",&x,&y);printf("infunctionmain,beforesandy=%d\n",x,y);swap(&x,&y);printf("infunctionmain,aftersandy=%d\n",x,y);}voidswap(int*u,int*v){intt;printf("infunctionswap,beforespandv=%p\n",u,v);t=*u;*u=*v;*v=t;printf("infunctionswap,afterspandv=%d\p",u,v);}xyswapuvt10201020↙

…x=10andy=20

…u=…andv=…201010

…u=…andv=…

…x=20andy=10158.3.2

指针作为参数的应用

例8.14将键盘输入的所有数字串逐个的转换为整数，并且依次存放于一个数组中。数字串前面可以加+、-号，各数字串之间至少用一个空格分开，用回车结束输入。#include"stdio.h"#include"ctype.h"#defineNUMBER100intgetint(int*pn){intc,sign;while(isspace(c=getchar()));/*跳过前导空格*/if(!isdigit(c)&&c!=EOF&&c!=ˊ+ˊ&&c!=ˊ-ˊ){printf("inputerror!\n");return0;}

/*若输入为非数字、非EOF、也不是+、-号，显示出错*/sign=(c==ˊ-ˊ)?-1:1;/*处理符号*/if(c=='+'||c=='-')c=getchar();/*跳过+、-号*/for(*pn=0;isdigit(c);c=getchar())*pn=10**pn+(c-ˊ0ˊ);/*将数字串转换为对应整数*/*pn*=sign;/*处理整数的符号*/returnc;}voidmain(void){inta[NUMBER],i,j,k;printf("inputintegersendswithEnter\n");for(i=0;i<NUMBER&&(k=getint(&a[i]))!=ˊ\nˊ;)if(k)i++;for(j=0;j<=i;j++)

printf("%8d",a[j]);printf("\n");}168.4数组的指针表示8.4.1

一维数组的指针表示目录inta[6],*p=a;/*或=&a[0]*/ap*(++p)=0;0

数组名是常量地址，其类型是数组元素类型指针。17pc=s 对字符指针变量pc赋值，使其指向字符数组s(即s[0])pc+i 结果为pc后面第i个元素的地址*(pc+i)结果为pc后面第i个元素*++pc 结果为pc加1之后所指元素++*pc 结果为pc所指元素加1*pc++ 结果为pc所指元素，然后pc加1(*pc)++

结果为pc所指元素，然后pc所指元素加1&pc 结果为字符指针变量pc的地址，类型为char**chars[6]={0,1,2,3,4,5},*pc;inti=2;spc运算符表23

特别提示：注意运算符的优先级和结合性！18chars[6]={0,1,2,3,4,5},*pc=&s[1];inti=2;spc运算符表s+i 结果为数组s中第i个元素的地址(即s[i]的地址)*(s+i)

结果为数组s中第i个元素s[i]++*s 结果为元素s[0]加1(*s)++

结果为元素s[0]的值，然后s[0]加1

特别提示：注意运算符的优先级和结合性！12s=pc 非法。数组名s是地址常量，不能进行赋值操作&s非法。数组名s是地址常量，不能取地址*++s 非法。不能对数组名s进行前缀++操作*s++非法。不能对数组名s进行后缀++操作××?××&s类型为char(*)[6]198.4.2

一维数组参数的指针表示

对于函数形如intf(inta[]，…){…}的形参a，其类型int[]实质上是整型指针，即：int*。S1=15intfun(intx[],intn){inti,sum=0;for(i=0;i<n;i++)s+=x[i];return(s);}voidmain(void){inty[]={1,2,3,4,5};printf(”s1=%d\n”,fun(y,5));

printf(”s2=%d\n”,fun(&y[2],3));}main：yfun：xint型地址单元S2=12int*x20

例8.15用指针变量表示一维数组参数，计算两个向量的数量积。

#include"stdio.h"#defineSIZE3doublescalar(double*a,double*b,intn);voidmain(void){doublex[SIZE],y[SIZE],*px,*py;for(px=x;px<x+SIZE;px++)scanf("%lf",px);getchar();for(py=y;py<&y[SIZE];)scanf("%lf",py++);px=x;py=y;printf("thescalarofvectorxandvectoryis%lf\n",scalar(px,py,SIZE));printf(");}doublescalar(double*a,double*b,intn){doubles,*p;printf("thevectorais\n");for(p=a;p<a+n;)printf("%lf\t",*p++);printf("\nthevectorbis\n");for(p=b;p<b+n;)printf("%lf\t",*p++);printf("\n");for(s=0,p=a;p<a+n;)s+=((*p++)*(*b++));returns;}218.4.3

用指向数组基本元素的指针表示多维数组

inta[4][2],*p=a[0];/*或=&a[0][0]*/ap*(p+0*2+0)*(p+0*2+1)*(p+1*2+0)*(p+1*2+1)*(p+2*2+0)*(p+2*2+1)*(p+3*2+0)*(p+3*2+1)inta[M][N],*p=a[0];/*或=&a[0][0]*/app+i*N+j在a[i][j]之前int单元个数*(p+i*N+j)a[0]a[1]a[2]a[3]什么类型的指针？?上机操作演示9-4-3.c22

例8.16用指向数组基本元素的指针变量实现三维数组元素的输入和输出。#include"stdio.h"#defineI2#defineJ3#defineK4voidmain(void){intv[I][J][K],*p=&v[0][0][0],n=1,i,j,k;for(i=0;i<I;i++)for(j=0;j<J;j++)for(k=0;k<K;k++)*(p+i*J*K+j*K+k)=n++;for(i=0;i<I;i++){for(j=0;j<J;j++){for(k=0;k<K;k++)printf("%4d",*(v[i][j]+k));printf("\n");}printf("\n");}}238.5指针数组8.5.1

指针数组的声明及使用

数组元素为指针类型的数组，称为指针数组。目录

int*p[3];p是有3个元素的整型指针数组(int*[3])。说明的顺序是：p

[3]

*

intp

char*pstr[]={”123”,”5678”};pstr是有2个元素的字符指针数组(char*[2])。pstr24

constintx=1,y=2;constint*ps[2];ps[0]=&x;ps[1]=&y;xyps

x和y变量是常量整型(constint)，即

x

和

y

是必须赋初值、且不得改变的变量，也称为符号常量。

ps是有2个数组元素的常量整型指针数组(const

int*[2])。

char*constpstr[]={”123”,”5678”};pstr

值不得改变！

const

char*constpstr[]={”123”,”5678”};pstr

值不得改变！25

例8.18理解指针数组含义的编程举例。#include"stdio.h"voidmain(void){intx=1,y=2,z=3,i;int*p[3];p[0]=&x;p[1]=&y;p[2]=&z;printf("&x=%p\tx=%d\n",&x,x);printf("&y=%p\ty=%d\n",&y,y);printf("&z=%p\tz=%d\n",&z,z);for(i=0;i<3;i++){printf("&p[%d]=%p\t",i,&p[i]);printf("p[%d]=%p\t“,i,p[i]);printf("*p[%d]=%d\n",i,*p[i]);}}pzyx&x=FFD0x=1&y=FFD2y=2&z=FFD4z=3&p[0]=FFD6p[0]=FFD0*p[0]=1&p[1]=FFD8p[1]=FFD2*p[1]=2&p[2]=FFDAp[2]=FFD4*p[2]=326

对指针数组中元素可以进行同类型指针允许的全部操作。

inta[]={1,2,3},b[]={4,5,6},*p[2];p[0]=a;/*对指针数组中的元素p[0]赋值，使之指向a数组*/p[1]=b;/*对指针数组中的元素p[1]赋值，使之指向b数组*/*p[0]=12;/*使a[0]=12*/++*p[1];/*间访b[0]并使其自增，结果为5，p[1]仍然指向b[0]*/*p[1]++;/*间访b[0]，然后p[1]自增，使p[1]指向b[1]*/apb125运算符表27

例8.19

未赋值指针数组引起的副作用举例。#include"stdio.h"#defineN6voidmain(void){inti,*p[N],sum=0;for(i=0;i<N;i++){scanf("%d",p[i]);sum+=*p[i];}for(i=0;i<N;i++)printf("p[%d]=%p,result=%d\n",i,p[i],*p[i]);

printf("sum=%d\n",sum);}p123456↙

p[0]=0000,result=4p[1]=FFDC,result=2p[2]=0580,result=3p[3]=0000,result=4p[4]=0040,result=5p[5]=0C39,result=6sum=21Nullpointerassignment28

例8.20解决未赋值指针数组引起的副作用举例。#include"stdio.h"#defineN6voidmain(void){

inti,a[N],*p[N],sum=0;

for(i=0;i<N;i++){p[i]=&a[i];scanf("%d",p[i]);sum+=*p[i];}for(i=0;i<N;i++)printf("p[%d]=%p,result=%d\n",i,p[i],*p[i]);

printf("sum=%d\n",sum);}pa123456↙

p[0]=FFCA,result=1p[1]=FFCC,result=2p[2]=FFCE,result=3p[3]=FFD0,result=4p[4]=FFD2,result=5p[5]=FFD4,result=6sum=2112345629#include"stdio.h"voidmain(void){intx0[5],x1[5],x2[5],x3[5],x4[5];int*p[5];inti,j;p[0]=x0;p[1]=x1;p[2]=x2,p[3]=x3,p[4]=x4;for(i=0;i<5;i++)for(j=0;j<5;j++)if(i==j)p[i][j]=1;elsep[i][j]=0;for(i=0;i<5;i++){for(j=0;j<5;j++)printf("%4d",p[i][j]);printf("\n");}}

例8.21用指针数组表示二维整型数组。px1x2x3x4x530

例8.22用字符指针数组表示出错提示字符串数组。#include"stdio.h"voiderror_prompt(interr_code);voidmain(void){intn;while(1){scanf("%d",&n);if(n==-1)break;error_prompt(n);}}voiderror_prompt(interr_code){char*perror[]={"can'topenfile!","readerror!","writeerror!","illegalaccessexception!"};printf("errorcode:%d:%s\n",err_code,perror[err_code]);}can'topenfile!\0perror1↙

Readerror!

－1↙

illegalaccessexception!\0readerror!\0writeerror!\0318.6带参数的main函数

目录8.6.1

命令行参数

命令行参数(command-linearguments)指在操作系统环境下执行一个可执行程序时为其所提供的实际参数。c:\>copyabc.txtdef.txt

在DOS下执行copy命令，将一个文件abc.txt的内容拷贝到另外一个文件def.txt。

C语言编制的可执行程序，对于命令行提供的实际参数，将由C程序之main函数定义的形式参数接受。即对于C语言，命令行参数就是main函数的参数。

在DOS下，命令行一般格式如下，文件名和参数以及参数和参数之间是空格符间隔。可执行文件名参数1

参数2

…

参数n328.6.2

带参main函数的声明及使用

声明具有命令行参数的main函数的一般形式是：类型main(intargc,char*argv[]){…//函数体

}其中，类型为main的函数类型；argc值表示命令行中字符串的个数；argv的每个字符指针元素指向一个命令行中的字符串。c:\>程序名参数1

参数2

…

参数nargcargv程序名\0…参数1\0参数2\0参数n\033#include"stdio.h"intmain(intargc,char*argv[]){intn=0;while(n<argc){printf(“%s”,argv[n]);

(n<argc-1)?printf(""):printf(“\n”);

n++;}printf("thenumberofcommand-lineargumentsare%d\n",argc);return0;}

例8.25回显命令行参数并显示命令行参数个数的程序实例。argcargvC:\>showIlikeCprogramming.↙\\\\\C:\>showIlikeCprogramming.C:\>thenumberofcommand-lineargumentsare534

例8.27用其它自定义名字表示main函数命令行形参的例子。

#include"stdio.h"intmain(intnum,char*v[]){

intn=0;while(n<num){printf("&v[%d]=%p\t",n,&v[n]);printf("&v[%d][0]=%p\t",n,v[n]);printf("v[%d]=%s\n",n,v[n]);

n++;}return0;}

程序中分别用整型形参num,和形参字符指针数组v来表示main函数的命令行参数。35

定义指针函数的一般形式是：类型*函数名(形参表){

…//函数体

}；其中，函数名之函数类型为类型*；类型为任意数据类型。

声明指针函数的一般形式是：类型*函数名(形参表)；其中，函数名之函数类型为类型*；类型为任意数据类型。8.7指针函数

8.7.1

指针函数的声明与定义

一个函数返回值为指针类型之函数，称为指针函数。目录

除了返回类型之外，指针函数与其它类型函数之特性一样。char*strcpy(char*t,char*s){char*p=t;while(*s++=*t++);returnp;}36#include"stdio.h"char*strstr(char*s,char*t){char*ps=s,*pt,*pc;while(*ps!=’\0’){for(pt=t,pc=ps;*pt!=’\0’&&*pt==*pc;pt++,pc++);if(*pt==’\0’)returnps;ps++;}return0;}voidmain(void){chars1[]="abcdefghijk12",s2[]="fgh",*p;p=strstr(s1,s2);printf("%p\t%s\n",&s1[0],s1);printf("%p\t%s\n",p,p);}8.7.2

指针函数的使用

例8.28

查找子串的指针函数应用举例。s1s2stpspt\\pFFCCabcdefghijkFFD1fghijk12pc37

声明函数指针的一般形式是：类型(*函数指针名)(形参表)；其中，函数指针名是指针变量名，所指函数的类型为类型(形参表)；类型为指向的函数类型；参数表是指向的函数形参表。8.8函数的指针

8.8.1

函数指针的声明

如果一个指针存放的是函数的入口地址，则该指针称为函数指针。函数指针变量函数

所指函数的类型和参数，必须与指针对象类型即类型(形参表)一致！目录38

函数指针赋值的一般形式是：函数指针名＝函数名;其中，函数名是已经定义的函数之名称，其类型应与函数指针名所指函数类型即类型(形参表)一致。

通过函数指针调用所指函数的一般形式是：(*函数指针名)(实参表)

或函数指针名(实参表)其中，实参表的参数个数与类型，应与函数指针名所指函数的形参表一致。函数名是地址常量，其值为函数之入口地址。39

例8.29

函数指针的应用举例。#include"stdio.h"voidf1(intx){printf("functionf1iscalled!\n");

printf("x=%d\n",x);}voidf2(intx,inty){printf("functionf2iscalled!\n");printf("x=%d\ty=%d\n",x,y);}voidmain(void){void(*pf1)(intx);void(*pf2)(intx,inty);pf1=f1;pf2=f2;pf1(5);pf2(10,20);(*pf1)(50);(*pf2)(100,200);}pf1pf2functionf1iscalled!x=5functionf2iscalled!x=10y=20functionf1iscalled!x=50functionf2iscalled!x=100y=200408.8.2

函数指针的应用

例8.30读取从键盘输入正文，再将正文以行为单位排序后输出。通过命令行参数-n决定排序方法。如果有命令行参数-n，则将输入行按照数值大小进行排序；否则将按照字典顺序排序。

mainreadlineswritelinessortnumcmpstrcmpgetlineswapvoidsort(void*v[],intn,int(*comp)(void*,void*)){inti,j;voids*v[],int,int);for(i=0;i<n-1;i++)for(j=0;j<n-i-1;j++) if((*comp)(v[j],v[j+1])>0)s);}418.9指向数组的指针（教材第11章内容）

8.9.1

指向数组指针的声明与定义

一个指针类型为数组的指针，称为数组指针。目录

声明指针函数的一般形式是：类型(*指针名)[M1][M2]…[Mn]；其中，指针名指向的数组之类型为类型[M1][M2]…[Mn]。

intu[2][3],*p=&u[0][0],(*p1)[3]=u；

upp1p数据类型为int*，其指向的存储单元之数据类型为int。p1数据类型为int(*)[3]，其指向的存储单元之数据类型为int[3]。

数组名是常量地址，其类型是数组元素类型指针。u地址类型为：int(*)[3]428.9.2

用数组名间访多维数组的元素

一个n维数组是其数组元素为n-1维数组的一维数组。intA[M1][M2][M3]…[Mn]；数组A是类型为[M1]一维数组，其元素是类型为int[M2][M3]…[Mn]的n-1维数组。

A是一个指向其数组元素——n-1维整型数组之常量指针，其值为n维数组之首地址。*A是A所指向n-1维整型数组。

int

a[3][2];aint(*)[2]int*int43

假设i,j,k,…,m,n皆未使数组下标越界，用数组名，数组名和下标操作符等非左值常量指针表示多维数组的元素形式是：

⑴对于二维整型数组u，其u[i][j]元的地址用指向数组元素的指针表示为：u[i]+j

用指向一维数组（下一级数组）的指针表示则为：*(u+i)+j

用间访形式访问其u[i][j]元可以表示为：*(u[i]+j)和*(*(u+i)+j)

int

a[3][2];aa[2]+1*(a+2)+1*(a[2]+1)*(*(a+2)+1)44

一个n维数组是其数组元素为n-1维数组的一维数组。intA[M1][M2][M3]…[Mn]；A是一个类型为：int（*）[M2][M3]…[Mn]；的数组的指针。

一般情况：一个n维数组的名字（或别名）是对应n-1维数组的指针。

*(A+i)是一个n-1维数组的别名，为对应n-2维数组的指针。类型为：

int（*）[M3]…[Mn]；等价形式为A[i]

*(*(A+i)+j)是一个n-2维数组的别名，为对应n-3维数组的指针。类型为：

int（*）[M4]…[Mn]；等价形式为A[i][j]可以理解0位数组的指针就是对应数据类型的指针（如int*）45

假设i,j,k,…,m,n皆未使数组下标越界，用数组名，数组名和下标操作符等非左值常量指针表示多维数组的元素形式是：⑵对于三维整型数组v，其v[i][j][k]元的地址用指向数组元素的指针v[i][j]表示为：v[i][j]+k

用指向一维数组的指针v[i]表示为：*(v[i]+j)+k

用指向二维数组（下一级数组）的指针v表示为：*(*(v+i)+j)+k

用间访形式访问其v[i][j][k]元可以表示为：*(v[i][j]+k),*(*(v[i]+j)+k),*(*(*(v+i)+j)+k)46

例11.2用数组名常量指针实现二维数组元素的输入和输出。#include"stdio.h"#defineN2#defineM3voidmain(void){

intu[N][M];intj;

/*用指向数组元素的指针完成第0行元素的输入*/for(j=0;j<M;j++)scanf("%d",u[0]+j);/*用指向下一级数组的指针完成第1行元素的输入*/for(j=0;j<M;j++)scanf("%d",*(u+1)+j);

/*用指向下一级数组的指针完成第0行元素的输出*/for(j=0;j<M;j++)printf("%6d",*(*(u+0)+j));printf("\n");

/*用指向数组元素的指针完成第1行元素的输出*/for(j=0;j<M;j++)printf("%6d",*(u[1]+j));printf("\n");}478.9.4

多维数组参数的指针表示1.形参为指向数组元素的指针

形参说明为指向数组元素的指针时，实参应为数组元素的地址，或为指向数组元素的指针变量。voidfun(int*p,intn);/*形参说明为指向数组元素的指针*/voidmain(void){intu[2][3],v[2][3][4];

…fun(u[0],2*3);/*实参u[0]是元素u[0][0]的地址*/

…fun(v[0][0],2*3*4);/*实参v[0][0]是元素v[0][0][0]的地址*/

…}488.9.4

多维数组参数的指针表示2.形参为指向下一级数组的指针

形参说明为指向下一级数组的指针时，实参应为数组名或指向下一级数组的指针。

voidf1(int(*p1)[3],intn);/*指向一维数组的指针p1为形参*/voidf2(int(*p2)[3][4],intn);/*指向二维数组的指针p2为形参*/voidmain(void){intu[2][3],v[2][3][4];

…f1(u,2*3);/*数组名u作为实参*/

…f2(v,2*3*4);/*数组名v作为实参*/

…}498.10用typedef定义类型

8.10.1

类型表达式

C中另外一类表达式