C语言第06章-指针

第6章指针《C语言程序设计》C程序设计中使用指针可以: 使程序简洁、紧凑、高效有效地表示复杂的数据结构动态分配内存得到多于一个的函数返回值主要内容指针的含义指针变量指针与数组指针与函数小结

6.1指针的含义变量与地址程序中:intii;

floatfk;

内存中每个字节有一个编号-----地址…...…...2000200120022005内存02003iifk

编译或函数调用时为其分配内存单元变量是对程序中数据存储空间的抽象说明：1.内存变量、内存单元的地址和内存单元中的内容一个变量名与该变量所占的内存空间首地址一一对应；通过内存变量名来对内存单元进行存取操作；编译时将变量名转换为变量的地址2.对变量值的访问方式：直接访问：按变量地址存取变量值间接访问：将变量ii地址存放在另一个变量ip中，首先通过变量ip找到变量ii的首地址，然后在访问变量ii.3.指向的概念变量ip中存放变量ii的地址，即称ip指向ii。变量ip称为指针变量…...…...2000200420062005整型变量ii10变量i_pointer200120022003指针与指针变量指针：一个变量的地址指针变量：专门存放变量地址的变量叫指针变量2000指针指针变量变量的内容变量的地址指针变量变量变量地址(指针)变量值指向地址存入指针变量&与*运算符含义含义:取变量的地址单目运算符优先级:2结合性:自右向左含义:

取指针所指向变量的内容单目运算符优先级:2结合性:自右向左例：&a为取变量a的地址，*p取指针所指向存储单元的数据。…...…...2000200420062005整型变量ii10变量i_pointer2001200220032000指针变量i_pointer-----指针变量，它的内容是地址量*i_pointer----指针的目标变量，它的内容是数据&i_pointer---指针变量占用内存的地址200010i_pointer*i_pointer&i_pointeriii_pointer&ii&(*i_pointer)ii*i_pointer*(&ii)i_pointer

=

&ii

=

&(*i_pointer)ii

=

*i_pointer

=

*(&ii)直接访问与间接访问直接访问：按变量地址存取变量值间接访问：通过存放变量地址的变量去访问变量例

ii=3;-----直接访问指针变量…...…...2000200420062005整型变量ii10变量i_pointer20012002200320003例*i_pointer=20;-----间接访问20指针变量…...…...2000200420062005整型变量ii10变量i_pointer2001200220032000整型变量ik10例

ik=ii;ik=*i_pointer;ii=*i_pointer+100;相当于： ii=ii+100;同样，与下面的语句也是等价的。 *ipointer=ii+100;例

ik=ii;--直接访问

ik=*i_pointer;--间接访问6.2

指针变量C语言规定所有变量在使用前必须定义。定义指针变量的一般形式为： 基类型*指针变量名；例如：

int*pi; float*pf;注意：1、int*p1,*p2;

与int*p1,p2;2、指针变量名是p1,p2,不是*p1,*p23、指针变量只能指向定义时所规定类型的变量4、指针变量定义后，变量值不确定，应用前必须先赋值6.2指针变量指针变量与其所指向的变量之间的关系指针变量的定义一般形式：[存储类型]

基类型*指针名；3变量i2000i_pointer*i_pointerii*i_pointer&iii_pointerii=3;*i_pointer=33变量ii2000i_pointer*i_pointerii*i_pointer&iii_pointerii=3;*i_pointer=3例int

*pi1,*pi2;float*qf;staticchar*name;注意：1、int*p1,*p2;

与int*p1,p2;2、指针变量名是p1,p2,不是*p1,*p23、指针变量只能指向定义时所规定类型的变量4、指针变量定义后，变量值不确定，应用前必须先赋值指针变量的初始化一般形式：[存储类型]

数据类型*指针名=初始地址值；赋给指针变量，不是赋给目标变量例intii;int*pi=ⅈ变量必须已说明过类型应一致例

int*p=ⅈ

int

ii;例intii;int*pi=ⅈint*pq=pi;用已初始化指针变量作初值例

voidmain(){intii;staticint*pi=ⅈ..............}(

)不能用auto变量的地址去初始化static型指针例#include<stdio.h>

voidmain(){intii=10;int*pi;*pi=ii;printf(“%d”,*pi);}危险！例

#include<stdio.h>

voidmain(){intii=10,ik;int*pi;

pi=&ik;*pi=ii;printf(“%d”,*pi);}指针变量必须先赋值,再使用…...…...2000200420062005整型变量ii10指针变量pi200120022003随机零指针与空类型指针零指针：(空指针)定义:指针变量值为零表示：int*p=0;

p指向地址为0的单元，系统保证该单元不作它用表示指针变量值没有意义#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是指向哪一种类型数据的指针变量6.2

指针变量6.2

指针变量例6.1举例说明指针。程序的输出结果为： icount=1,ix=1

#include<stdio.h>voidmain(){inticount=0,ix;int*pi;pi=&icount;icount++;ix=*pi;printf("icount=%d,ix=%d\n",icount,ix);}…...…...f86f8af8cf8b变量icount0指针变量pif87f88f89f86变量ix11例指针的概念#include<stdio.h>voidmain(){intia;int*pa=&ia;ia=10;printf(“ia:%d\n",ia);printf("*pa:%d\n",*pa);printf("&ia:%x(hex)\n",&ia);printf("pa:%x(hex)\n",pa);printf("&pa:%x(hex)\n",&pa);}运行结果：ia:10*pa:10&ia:f86(hex)pa:f86(hex)&pa:f88(hex)…...…...f86f8af8cf8b整型变量ia10指针变量paf87f88f89f86例输入两个数，并使其从大到小输出#include<stdio.h>voidmain(){int*p1,*p2,*p,ia,ib;scanf("%d,%d",&ia,&ib);p1=&ia;p2=&ib;if(ia<ib){p=p1;p1=p2;p2=p;}printf(“ia=%d,ib=%d\n",ia,ib);printf("max=%d,min=%d\n",*p1,*p2);}运行结果：ia=5,ib=9max=9,min=5…...…...指针变量p1指针变量p20002008200220042006指针变量p2整型变量ib整型变量ia5200692008200620082006指针变量作为函数参数——地址传递特点：共享内存,“双向”传递#include<stdio.h>voidswap(intix,intiy){intitemp;temp=ix;ix=iy;iy=temp;}voidmain(){intia,ib;scanf("%d,%d",&ia,&ib);if(ia<ib)swap(ia,ib);printf("\n%d,%d\n",ia,ib);}例

将数从大到小输出…...…...20002008200A2002200420065变量ia变量ib(main)9变量itemp变量iy变量ix(swap)55959COPY指针变量作为函数参数——地址传递特点：共享内存,“双向”传递#include<stdio.h>swap(intix,intiy){intitemp;itemp=ix;ix=iy;iy=itemp;}voidmain(){intia,ib;scanf("%d,%d",&ia,&ib);if(ia<ib)swap(ia,ib);printf("\n%d,%d\n",ia,ib);}例

将数从大到小输出值传递运行结果：5,9#include<stdio.h>swap(int*p1,int*p2){intip;ip=*p1;*p1=*p2;*p2=ip;}voidmain(){intia,ib;int*pointer_1,*pointer_2;scanf("%d,%d",&ia,&ib);

pointer_1=&ia;pointer_2=&ib;if(ia<ib)swap(pointer_1,pointer_2);printf("\n%d,%d\n",ia,ib);}…...20002008200A200220042006200C200E2010...59整型变量ia整型变量ib(main)指针pointer_1指针pointer_220002002(swap)指针p1指针p2整型p5920002002COPY5例

将数从大到小输出#include<stdio.h>voidswap(int*p1,int*p2){intip;ip=*p1;*p1=*p2;*p2=ip;}voidmain(){intia,ib;int*pointer_1,*pointer_2;scanf("%d,%d",&ia,&ib);pointer_1=&ia;pointer_2=&ib;if(ia<ib)swap(pointer_1,pointer_2);printf("\n%d,%d\n",ia,ib);}…...20002008200A200220042006200C200E2010...59整型变量ia整型变量ib(main)指针pointer_1指针pointer_22000200259例

将数从大到小输出运行结果：9，5值传递但传递的是地址#include<stdio.h>voidswap(int*p1,int*p2){int*p;*p=*p1;*p1=*p2;*p2=*p;}voidmain(){intia,ib;int*pointer_1,*pointer_2;scanf("%d,%d",&ia,&ib);

pointer_1=&ia;pointer_2=&ib;if(ia<ib)swap(pointer_1,pointer_2);printf("\n%d,%d\n",ia,ib);}运行结果：9，9编译警告！结果不对！intx;int*p=&x;x;例

将数从大到小输出…...20002008200A200220042006200C200E2010...59整型变量ia整型变量ib(main)指针pointer_1指针pointer_2200020029920002002COPY(swap)指针p1指针p2指针p****假设2000指针变量在使用前必须赋值！#include<stdio.h>voidswap(intix,intiy){intit;it=ix;ix=iy;iy=it;}voidmain(){intia,ib;int*pointer_1,*pointer_2;scanf("%d,%d",&ia,&ib);

pointer_1=&ia;pointer_2=&ib;if(ia<ib)swap(*pointer_1,*pointer_2);printf("\n%d,%d\n",ia,ib);}运行结果：5，9例

将数从大到小输出值传递运行结果：5，9例

将数从大到小输出#include<stdio.h>voidswap(int*p1,int*p2){int*p;p=p1;p1=p2;p2=p;}voidmain(){intia,ib;int*pointer_1,*pointer_2;scanf("%d,%d",&ia,&ib);

pointer_1=&ia;pointer_2=&ib;if(ia<ib)swap(pointer_1,pointer_2);printf("%d,%d",*pointer_1,*pointer_2);}…...20002008200A200220042006200C200E2010...59整型ia整型ib(main)pointer_1pointer_22000200220002002COPY(swap)指针p1指针p2指针p****2000值传递200020026.3指针与数组指向数组元素的指针变量例intiarray[10];int*p;

p=&iarray[0];//p=array;或int*p=&iarray[0];或int*p=iarray;iarray[0]iarray[1]iarray[2]iarray[3]iarray[9]...整型指针p&iarray[0]p数组名是表示数组首地址的地址常量指针的运算指针变量的赋值运算p=&ia;(将变量ia地址p)p=iarray;(将数组iarray首地址p)p=&iarray[i];(将数组元素地址p)p1=p2;(指针变量p2值p1)不能把一个整数p,也不能把p的值整型变量如

intii,*p;p=1000;(

)ii=p;(

)指针变量与其指向的变量具有相同数据类型指针的算术运算：piipiid(ii为整型数，d为p指向的变量所占字节数)p++,p--,p+ii,p-ii,p+=ii,p-=ii等假设p1与p2指向同一数组，p1-p2=两指针间元素个数(p1-p2)/dp1+p2无意义例p指向float数，那么p+1p+14例p指向int型数组，且p=&ia[0];那么p+1指向ia[1]例inta[10];int*p=&ia[2];p++;*p=1;例intia[10];int*p1=&ia[2];int*p2=&ia[5];那么：p2-p1=3;ia[0]ia[1]ia[2]ia[3]ia[4]ia[5]ia[6]ia[7]ia[8]ia[9]a数组pp+1,ia+1p+ii,ia+iip+9,ia+91指针变量的关系运算假设p1和p2指向同一数组，那么p1<p2表示p1指的元素在前p1>p2表示p1指的元素在后p1==p2表示p1与p2指向同一元素假设p1与p2不指向同一数组，比较无意义p==NULL或p!=NULL数组元素表示方法ia[0]ia[1]ia[2]ia[3]ia[9]...iaia+9ia+1ia+2地址元素下标法ia[0]ia[1]ia[2]ia[9]ia[0]ia[1]ia[2]ia[3]ia[9]...pp+9p+1p+2地址元素指针法*p*(p+1)*(p+2)*(p+9)[]变址运算符ia[ii]

*(ia+ii)ia[ii]

p[ii]

*(p+ii)

*(ia+ii)*ia*(ia+1)*(ia+2)*(ia+9)p[0]p[1]p[2]p[9]ia[0]ia[1]ia[2]ia[3]ia[4]例数组元素的引用方法#include<stdio.h>voidmain(){intia[5],*pa,ii;for(ii=0;ii<5;ii++) ia[ii]=ii+1;

pa=ia;for(ii=0;ii<5;ii++) printf("*(pa+%d):%d\n",ii,*(pa+ii));for(ii=0;ii<5;ii++) printf("*(ia+%d):%d\n",i,*(ia+ii));for(ii=0;ii<5;ii++) printf("pa[%d]:%d\n",ii,pa[ii]);for(ii=0;ii<5;ii++) printf("a[%d]:%d\n",ii,ia[ii]);}12345pa例intia[]={1,2,3,4,5,6,7,8,9,10},*pi=ia,ii;数组元素地址的正确表示：

〔A〕&(ia+1)〔B〕ia++〔C〕&pi〔D〕&p[ii]

数组名是地址常量pi++,pi--(

)ia++,ia--(

)ia+1,*(ia+2)(

)例#include<stdio.h>

voidmain(){intia[]={5,8,7,6,2,7,3};intiy,*pi=&ia[1];

iy=(*--pi)++;printf(“%d”,iy);printf(“%d”,ia[0]);}输出：56pipi58762730123456ia例注意指针变量的运算6#include<stdio.h>voidmain(){intii,*pi,ia[7];

pi=ia;for(ii=0;ii<7;ii++)scanf("%d",pi++);printf("\n");for(ii=0;ii<7;ii++,pi++)printf("%d",*pi);}例注意指针的当前值pi=ia;pipi58762730123456iapipipipipipi指针变量可以指到数组后的内存单元数组名作函数参数数组名作函数参数，是地址传递数组名作函数参数，实参与形参的对应关系实参形参数组名指针变量数组名指针变量数组名数组名指针变量指针变量例将数组a中的n个整数按相反顺序存放iiij

379110675420123456789iiijiiijiiijijii11760594723#include<stdio.h>voidinv(intix[],intin){intit,ii,ij,im=(in-1)/2;for(ii=0;ii<=im;ii++){ij=in-1-ii;it=ix[ii];ix[ii]=ix[ij];ix[ij]=it;}}voidmain(){intii,ia[10]={3,7,9,11,0,6,7,5,4,2};inv(ia,10);printf("Thearrayreverted:\n");for(ii=0;ii<10;ii++)printf("%d,",ia[ii]);printf("\n");}im=4实参与形参均用数组例将数组a中的n个整数按相反顺序存放#include<stdio.h>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;}}voidmain(){intii,ia[10]={3,7,9,11,0,6,7,5,4,2};inv(ia,10);printf("Thearrayreverted:\n");for(ii=0;ii<10;ii++)printf("%d,",ia[ii]);printf("\n");}实参用数组,形参用指针变量37911067542ia[0]ia[1]ia[2]ia[3]ia[4]ia[5]ia[6]ia[7]ia[8]ia[9]xp=x+ma数组60711594723ijijijjiji例将数组a中的n个整数按相反顺序存放#include<stdio.h>voidinv(int*px,intin){intit,*pi,*pj,*p,im=(in-1)/2;pi=px;pj=px+in-1;p=px+im;for(;pi<=p;pi++,pj--){it=*pi;*pi=*pj;*pj=it;}}voidmain(){intii,ia[10],*p=ia;for(ii=0;ii<10;ii++,p++)scanf("%d",p);

p=ia;

inv(p,10);printf("Thearrayhasbeenreverted:\n");for(p=ia;p<ia+10;p++)printf("%d",*p);}实参与形参均用指针变量例将数组a中的n个整数按相反顺序存放#include<stdio.h>voidinv(intix[],intin){intit,ii,ij,im=(in-1)/2;for(ii=0;ii<=im;ii++){ij=in-1-ii; it=ix[ii];ix[ii]=ix[ij];ix[ij]=it;}}voidmain(){intii,ia[10],*p=ia;for(ii=0;ii<10;ii++,p++)scanf("%d",p);

p=ia;

inv(p,10);printf("Thearrayhasbeenreverted:\n");for(p=ia;p<ia+10;p++)printf("%d",*p);}实参用指针变量,形参用数组一级指针变量与一维数组的关系int*p与intq[10]数组名是指针〔地址〕常量p=q;p+ii是q[ii]的地址数组元素的表示方法:下标法和指针法，即假设p=q,那么p[ii]q[ii]*(p+ii)*(q+ii)形参数组实质上是指针变量，即intq[]int*q在定义指针变量〔不是形参〕时，不能把int*p写成intp[];系统只给p分配能保存一个指针值的内存区(int型2字节〕；而给q分配2*10字节的内存区6.3.2指针与字符串字符串表示形式用字符数组实现例#include<stdio.h>voidmain(){charstring[]="IloveChina!";printf("%s\n",string);printf("%s\n",string+7);}IloveChistring[0]string[1]string[2]string[3]string[4]string[5]string[6]string[7]string[8]string[9]stringstring[10]string[11]string[12]string[13]n!a\0结果为：IloveChina!China!用字符指针实现例#include<stdio.h>voidmain(){char*string="IloveChina!";printf("%s\n",string);string+=7;while(*string){putchar(string[0]);string++;}}IloveChistringn!a\0字符指针初始化:把字符串首地址赋给string

char*string;

string="IloveChina!";string*string!=0字符串指针作函数参数例用函数调用实现字符串复制〔1〕用字符数组作参数〔2〕用字符指针变量作参数aIamateaceh\0r.fromabyuarasutndetoboet.\0Iaaeceh\0r.t.\0mta#include<stdio.h>voidcopy_string(charfrom[],charto[]){inti=0;while(from[i]!='\0'){to[i]=from[i]; i++;}to[i]='\0';}voidmain(){chara[]="Iamateacher.";charb[]="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);}#include<stdio.h>voidcopy_string(char*from,char*to){for(;*from!='\0';from++,to++)*to=*from;*to='\0';}voidmain(){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);}字符指针变量与字符数组char*cp;与charstr[20];str由假设干元素组成，每个元素放一个字符；而cp中存放字符串首地址charstr[20];str="IloveChina!";()char*cp;cp="IloveChina!";()str是地址常量；cp是地址变量cp接受键入字符串时,必须先开辟存储空间例charstr[10];scanf("%s",str);(

)而char*cp;scanf("%s",cp);(

)改为:char*cp,str[10];cp=str;scanf("%s",cp);(

)字符串与数组关系字符串用一维字符数组存放字符数组具有一维数组的所有特点数组名是指向数组首地址的地址常量数组元素的引用方法可用指针法和下标法数组名作函数参数是地址传递等区别存储格式：字符串结束标志赋值方式与初始化输入输出方式：%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};(

)scanf("%s",str);printf("%s",str);gets(str);puts(str);

指针数组因为指针也是变量，因此可设想用指向同一数据类型的指针来构成一个数组，这就是指针数组。数组中的每个元素都是指针变量，并且指针数组中每个元素都为指向同一数据类型的指针。定义指针数组的一般形式为：

类型名*数组名[元素个数];

例如: int*pi[10];定义：数组中的元素为指针变量定义形式：数据类型*数组名[数组长度说明]；数组中的每个元素都是指针变量，并且指针数组中每个元素都为指向同一数据类型的指针。例int*p[4];指针所指向变量的数据类型指针数组赋值与初始化赋值:voidmain(){intb[2][3],*pb[2];

pb[0]=b[0];pb[1]=b[1];……..}int*pb[2]pb[0]pb[1]intb[2][3]123246初始化:voidmain(){intb[2][3],*pb[]={b[0],b[1]};……..}int*pb[2]pb[0]pb[1]intb[2][3]123246指针数组指针数组赋值与初始化Lisp\0Fortran\0Basic\0p[0]p[1]p[2]p[3]0赋值:voidmain(){chara[]="Fortran";charb[]="Lisp";charc[]="Basic";

char*p[4];

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

charname[5][9]={“gain”,“much”,“stronger”,“point”,“bye”};

char*name[5]={“gain”,“much”,“stronger”,“point”,“bye”};gain\0stronger\0point\0much\0name[0]name[1]name[2]name[3]name[4]bye\0gain\0stronger\0point\0much\0bye\0二维数组与指针数组区别：二维数组存储空间固定字符指针数组相当于可变列长的二维数组分配内存单元=数组维数*2+各字符串长度指针数组元素的作用相当于二维数组的行名但指针数组中元素是指针变量二维数组的行名是地址常量

指针数组例6.4将数字1－12转换成相应月份的英文名称。例6.4源程序例6.5将假设干字符串按字母顺序〔由小到大〕排序。例6.5源程序 程序运行结果为： badminton basketball football tennis volleyball/*例6.4源程序*/#include<stdio.h>voidmain(){staticchar*cname[]={"Illegalmonth","January","February","March","April","May","June","July","August","September",October","November","December"};char*cmonth;intii;printf("PleaseinputmonthNo.(1--12):");scanf("%d",&ii);cmonth=(ii<1||ii>12)?cname[0]:cname[ii];printf("%s\n",cmonth);}/*例6.5将假设干字符串按字母顺序〔小到大〕排序*/#include<stdio.h>#include<string.h>voidmain(){char*cstring[]={"football","basketball","volleyball","badminton","tennis"};char*ctemp; intin=5; intii,ij,ik;for(ii=0;ii<in-1;ii++){ ik=ii; for(ij=ii+1;ij<in;ij++) if(strcmp(cstring[ik],cstring[ij])>0) ik=ij; if(ik!=ii) { ctemp=cstring[ii]; cstring[ii]=cstring[ik]; cstring[ik]=ctemp; }}for(ii=0;ii<in;ii++) printf("%s\n",cstring[ii]);}

指针与二维数组用指针变量可以指向一维数组中的元素，也可以指向多维数组中的元素，但在概念上和使用上复杂一些。定义二维数组：

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

例6.6使用指针输出二维数组的全部元素。#include<stdio.h>voidmain(){ intia[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}}; int*pi,ii;

pi=ia[0]; for(ii=0;ii<12;ii++) { printf("%d,",*pi++); } printf("\n");}例inta[3][4];a[0][0]a[0][1]a[0][2]a[0][3]a[1][0]a[1][1]a[1][2]a[1][3]a[2][0]a[2][1]a[2][2]a[2][3]每个元素a[i]由包含4个元素的一维数组组成二维数组a是由3个元素组成a[0]a[1]a[2]行名此时需要一个可指向一个包含n个元素的数组的指针p，且指针p的增值以一维数组的长度为单位，使这样的指针变量指向二维数组的某一行时，p+1就指向了该二维数组的下一行，这样的指针变量称为数组指针。

指针与二维数组

指针与二维数组定义数组指针的一般形式为： 类型名(*指针变量名)[元素个数]; 例如，在程序定义一个数组指针： int(*pi)[4];它说明指针变量pi指向的存储空间包含有四个整型元素，即数组指针pi指向一个一维数组，pi的值就是该数组的首地址。

指针与二维数组例6.7利用数组指针处理二维数组。例6.7源程序程序的运行结果如下： 0,1,2,3,4,5,6,7,8,9,10,11,#include<stdio.h>voidmain(){ intia[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}}; int(*pi)[4],ii,ij;

for(ii=0;ii<3;ii++) { pi=ia[ii]; for(ij=0;ij<4;ij++) printf("%d,",(*pi)[ij]); } printf("\n");}

指针与二维数组2、多级指针由于指针变量直接指向变量，所以称为一级指针。而如果通过指向指针的指针变量来访问变量那么构成了二级或多级指针指向指针的指针变量说明的一般形式为： 类型名**指针变量名； 例如： int**ppi;表示ppi是一个指针变量，它指向另一个指针变量，而这个指针变量指向一个整型量。intia,*pi,**ppi;ia=3pi=&ia;ppi=π**ppi=6;&pi&iappipi3ia6二级间接寻址例一级指针与二级指针lt6_23.c#include<stdio.h>voidswap(int**r,int**s){int*t;t=*r;*r=*s;*s=t;}voidmain(){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)指针变量t200020022000

指针与二维数组例6.8利用二级指针处理二维数组#include<stdio.h>voidmain(){ intia[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}}; int**ppi,ii,ij;

for(ii=0;ii<3;ii++) { *ppi=ia[ii]; for(ij=0;ij<4;ij++) printf("%d,",(*ppi)[ij]); } printf("\n");}运行结果如下：0,1,2,3,4,5,6,7,8,9,10,11,6.4

指针与函数当使用指针作函数的形参时，是以数据的地址作为实参调用函数，它的作用是将一个变量的地址传送到函数中。例6.9利用指针实现两个数据的交换函数。例题源程序程序的运行结果如下： Inputia,ib:5,6 a=6,b=56.4

指针与函数例6.10中给出用指针作为形参，数组名作为实参的方式。函数arraySum用来计算一个整数数组所包含的所有元素的和。例题源程序程序的运行结果如下： Thesumis266.4

指针与函数在Ｃ语言中允许一个函数的返回值是一个指针(即地址)，这种返回指针值的函数称为指针型函数。定义指针型函数的一般形式为：

类型名*函数名(形参列表) {

……/*函数体*/ }

6.4

指针与函数例如： int*fi(intix,intiy) { ....../*函数体*/ }6.