第六节 二维数组和指针 二维数组的地址 对于一维数组: （1）数组名array表示数组的首地址， 即array[0]的地址； 第六节 二维数组和指针 二维数组的地址 对于一维数组: （1）数组名array表示数组的首地址， 即array[0]的地址； （2）数组名array是地址常量 （3）array+i是元素array[i]的地址 （4）array[i]  *(array+i) array int array[10];

int a[3][4]; int a[3] ; [4] a a+1 a+2 行指针与列指针 地址 a[0]+0 a[0]+1 a[0]+2 对应值 *(a[0]+0) *(a[0]+1) *(a[0]+2) *(a[1]+0) *(a[1]+1) *(a[1]+2) *(a[2]+0) *(a[2]+1) *(a[2]+2) a[0] a[1] a[2] 2000 2008 2016 a a+1 a+2 2000 2002 2008 2010 2016 2018 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] a[0]+i a[1]+i a[2]+i *(a+0)+i *(a+1)+i *(a+2)+i 对于二维数组： （1）a是数组名， 包含三个元素 a[0],a[1],a[2] （2）每个元素a[i] 又是一个一维 数组，包含4个 元素 基类型

int a[3][4]; a a+1 a+2 a[0] a[1] a[2] 2000 2008 2016 2002 2010 2018 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列元素地址，指向列

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

指向二维数组元素的指针变量 p p+1 p+2 p+7 p+11 main() int a[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] p 例 指向二维数组元素的指针变量 p+1 p+2 main() { static int a[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+7 p=*a; p=&a[0][0]; p=*(a+0); p=a; p+11

a a+1 a+2 p p+1 p+2 p[0]+1或 *p+1 p[1]+2或 *(p+1)+2 p的值是一维数组的 首地址，p是行指针 指向一维数组的指针变量 定义形式： 数据类型 (*指针名)[一维数组维数]; 例 int (*p)[4]; int a[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] a a+1 a+2 p p+1 p+2 可让p指向二维数组某一行 如 int a[3][4], (*p)[4]=a; p[0]+1或 *p+1 p[1]+2或 *(p+1)+2 p的值是一维数组的 首地址，p是行指针 ( )不能少 int (*p)[4]与int *p[4]不同 *(*p+1)或 (*p)[1] *(*(p+1)+2) 一维数组指针变量维数和 二维数组列数必须相同

p p p 例 一维数组指针变量举例 main() 例 一维数组指针变量举例 int a[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] p main() { static int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23}; int i,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  p[0][j] p p=a[0]; p=*a; p=&a[0][0]; p=&a[0];

指向指针的指针（二级指针） main() { int a[3][4]= { {1,2,3,4}, {3,4,5,6}, {5,6,7,8} }; int i; int **p=a; for(i=0;i<3;i++) for (j=0;j<4;j++) printf("%d,", *(*(p+i)+j); } 格式： 类型名 **指针名； *p *p+1 *p+2 *p+3 p 1 2 3 4 5 6 7 8 p+1 p+2

第七节 二维数组的指针作函数参数 一、 形参的格式 1. 用指向数组的指针变量 例：fun(double (*p)[N] 第七节 二维数组的指针作函数参数 一、 形参的格式 1. 用指向数组的指针变量 例：fun(double (*p)[N] 2. 用二维数组 例：fun(double a[][N]); 或: fun(double a[M][N] 3. 用二级指针 例：fun(double **p); 4. 用指针数组 例：fun(double *a[M]); 或 fun(double *a[]);

例 3个学生各学4门课，计算总平均分，并输出第n个学生成绩 函数说明 void average(float *p,int n) { float *p_end, sum=0,aver; p_end=p+n-1; for(;p<=p_end;p++) sum=sum+(*p); aver=sum/n; printf("average=%5.2f\n",aver); } void search(float (*p)[4], int n) { int i; printf(" No.%d :\n",n); for(i=0;i<4;i++) printf("%5.2f ",*(*(p+n)+i)); main() { void average(float *p,int n); void search(float (*p)[4],int n); float score[3][4]= {{65,67,79,60},{80,87,90,81}, {90,99,100,98}}; average(*score,12); search(score,2); } p 列指针 行指针 float p[][4] p 65 52 79 60 80 87 90 81 99 100 98  p[n][i]

例 3个学生各学4门课，计算总平均分，并查找一门以上课 不及格学生， 输出其各门课成绩 例 3个学生各学4门课，计算总平均分，并查找一门以上课 不及格学生， 输出其各门课成绩 void search(float (*p)[4], int n) { int i,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.%d is fail,his scores are:\n",j+1); printf("%5.1f ",*(*(p+j)+i)); printf("\n"); } main() { void search(float (*p)[4], int n); float score[3][4]={{...},{...},{...}}; search(score,3); 65 52 79 60 80 87 90 81 99 100 98 p  p[j][i]

输出杨辉三角形(程序见P133） 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 分析 特点是: 第一列是1 对角线为1 从第三行开始，每数是它上面前一列和它对应列的和 可用 a[i][j]=a[i-1][j-1]+a[i-1][j]表示

6.4 指针与字符串 字符串表示形式 用字符数组实现 例 main( ) { char string[]=“I love China!”; \0 例 main( ) { char string[]=“I love China!”; printf(“%s\n”,string); printf(“%s\n”,string+7); } String+7 运行结果： I love China! China!

字符指针初始化:把字符串首地址赋给string  char *string; string=“I love China!”; 用字符指针实现 I l o v e C h i string n ! a \0 字符指针初始化:把字符串首地址赋给string  char *string; string=“I love China!”; 例 main( ) { char *string=“I love China!”; printf(“%s\n”,string); string+=7; while(*string) { putchar(*string); string++; } string *string!=0

字符串指针作函数参数 void copy_string(char from[],char to[]) { int i=0; e c h \0 r . from b y u a r s t n d e to o . \0 I a e c h \0 r . t m void copy_string(char from[],char to[]) { int i=0; while(from[i]!='\0') { to[i]=from[i]; i++; } to[i]='\0'; main() { char a[]="I am a teacher."; char b[]="You are a student."; printf("string_a=%s\n string_b=%s\n",a,b); copy_string(a,b); printf("\nstring_a=%s\nstring_b=%s\n",a,b); 例 用函数调用实现字符串复制 void copy_string(char *from,char *to) { for(;*from!='\0';from++,to++) *to=*from; *to='\0'; } main() { char *a="I am a teacher."; char *b="You are a student."; printf("string_a=%s\nstring_b=%s\n",a,b); copy_string(a,b); printf("\nstring_a=%s\nstring_b=%s\n",a,b); （1）用字符数组作参数 （2）用字符指针变量作参数

字符指针变量与字符数组 char *cp; 与 char str[20]; str由若干元素组成，每个元素放一个字符；而cp中存放字符串首地址 char str[20]; str=“I love China!”; () char *cp; cp=“I love China!”; () str是地址常量；cp是地址变量 cp接受键入字符串时,必须先开辟存储空间 例 char str[10]; scanf(“%s”,str); () 而 char *cp; scanf(“%s”, cp); () 改为: char *cp,str[10]; cp=str; scanf(“%s”,cp); ()

字符串与数组关系 字符串用一维字符数组存放 字符数组具有一维数组的所有特点 数组名是指向数组首地址的地址常量 数组元素的引用方法可用指针法和下标法 数组名作函数参数是地址传递等 区别 存储格式：字符串结束标志 赋值方式与初始化 输入输出方式：%s %c scanf(“%s”,str); printf(“%s”,str); gets(str); puts(str); char str[]={“Hello!”}; () char str[]=“Hello!”; () char str[]={‘H’,‘e’,‘l’,‘l’,‘o’,‘!’}; () char *cp=“Hello”; () int a[]={1,2,3,4,5}; () int *p={1,2,3,4,5}; () char str[10],*cp; int a[10],*p; str=“Hello”; () cp=“Hello!”; () a={1,2,3,4,5}; () p={1,2,3,4,5}; ()

6.5 指针与函数 函数指针：函数在编译时被分配的入口地址,用函数名表示 指向函数的指针变量 定义形式： 数据类型 (*指针变量名)(); 6.5 指针与函数 函数指针：函数在编译时被分配的入口地址,用函数名表示 max …... 指令1 指令2 指向函数的指针变量 定义形式： 数据类型 (*指针变量名)(); 如 int (*p)(); 函数指针变量赋值:如p=max; ( )不能省 int (*p)() 与 int *p()不同 专门存放函数入口地址 可指向返回值类型相同的不同函数 函数返回值的数据类型 函数调用形式： c=max(a,b);  c=(*p)(a,b);  c=p (a,b); 对函数指针变量pn, p++, p--无意义 函数指针变量指向的函数必须有函数说明

例 用函数指针变量调用函数，比较两个数大小 main() { int max(int ,int), (*p)(); int a,b,c; p=max; scanf("%d,%d",&a,&b); c=(*p)(a,b); printf("a=%d,b=%d,max=%d\n",a,b,c); } int max(int x,int y) { int z; if(x>y) z=x; else z=y; return(z); main() { int max(int ,int); int a,b,c; scanf("%d,%d",&a,&b); c=max(a,b); printf("a=%d,b=%d,max=%d\n",a,b,c); } int max(int x,int y) { int z; if(x>y) z=x; else z=y; return(z);

用函数指针变量作函数参数 例 用函数指针变量作参数，求最大值、最小值和两数之和 void main() max(int x,int y) 例 用函数指针变量作参数，求最大值、最小值和两数之和 void main() { int a,b,max(int,int), min(int,int),add(int,int); void process(int,int,int (*fun)()); scanf("%d,%d",&a,&b); process(a,b,max); process(a,b,min); process(a,b,add); } void process(int x,int y,int (*fun)()) { int result; result=(*fun)(x,y); printf("%d\n",result); max(int x,int y) { printf(“max=”); return(x>y?x:y); min(int x,int y) { printf(“min=”); return(x<y?x:y); add(int x,int y) { printf(“sum=”); return(x+y);

6.6 返回指针值的函数 函数定义形式： main() { float score[][4]={{60,70,80,90}, {56,89,67,88},{34,78,90,66}}; float *search(float (*pointer)[4],int n), *p; int i,m; printf("Enter the number of student:"); scanf("%d",&m); printf("The scores of No.%d are:\n",m); p=search(score,m); for(i=0;i<4;i++) printf("%5.2f\t",*(p+i)); } float *search(float (*pointer)[4], int n) { float *pt; pt=*(pointer+n); return(pt); 6.6 返回指针值的函数 函数定义形式： 类型标识符 *函数名(参数表); 例 int *f(int x, int y) 例 指针函数实现：有若干学生成绩，要求输入学生序号后， 能输出其全部成绩 p p p p pointer pointer+1 34 78 90 66 56 89 67 88 60 70 80 score数组

例 写一个函数，求两个int型变量中居于较大值的变量的地址 int *f1(int *x,int *y) { if(*x>*y) return x; else return y; } main() { int a=2,b=3; int *p; p=f1(&a, &b); printf("%d\n",*p); …... 2000 2008 200A 2002 2004 2006 变量a 变量b (main) 指针变量p COPY 2 3 ** 指针变量y 指针变量x (f1) 2000 2002

例 写一个函数，求两个int型变量中居于较大值的变量的地址 int *f3(int *x,int *y) { if(*x>*y) return x; else return y; } main() { int a=2,b=3; int *p; p=f1(&a,&b); printf("%d\n",*p); …... 2000 2008 200A 2002 2004 2006 2 变量a 变量b (main) 3 指针变量p ** 2002

例 写一个函数，求两个int型变量中居于较大值的变量的地址 int *f3(int x,int y) { if(x>y) return &x; else return &y; } main() { int a=2,b=3; int *p; p=f3(a, b); printf("%d\n",*p); …... 2000 2008 200A 2002 2004 2006 变量a 变量b (main) 指针变量p COPY 2 3 ** 变量y 变量x (f3) 2 3

例 写一个函数，求两个int型变量中居于较大值的变量的地址 int *f3(int x,int y) { if(x>y) return &x; else return &y; } main() { int a=2,b=3; int *p; p=f3(a,b); printf("%d\n",*p); …... 2000 2008 200A 2002 2004 2006 2 变量a 变量b (main) 3 指针变量p ** 200A 不能返回形参或局部变量 的地址作函数返回值

6.7 指针数组和多级指针 用于处理二维数组或多个字符串 指针数组 定义：数组中的元素为指针变量 6.7 指针数组和多级指针 用于处理二维数组或多个字符串 指针数组 定义：数组中的元素为指针变量 定义形式：[存储类型] 数据类型 *数组名[数组长度说明]； 例 int *p[4]; 指针数组赋值与初始化 指针本身的存储类型 指针所指向变量的数据类型 赋值: main() { int b[2][3],*pb[2]; pb[0]=b[0]; pb[1]=b[1]; …….. } int *pb[2] pb[0] pb[1] int b[2][3] 1 2 3 4 6 区分int *p[4]与int (*p)[4] 初始化: main() { int b[2][3],*pb[ ]={b[0],b[1]}; …….. } int *pb[2] pb[0] pb[1] int b[2][3] 1 2 3 4 6

p[0]=a; p[1]=b; p[2]=c; p[3]=NULL; …….. } 或: { char *p[4]; 指针数组赋值与初始化 L i s p \0 F o r t r a n \0 B a s i c \0 p[0] p[1] p[2] p[3] 赋值: main() { char a[]="Fortran"; char b[]="Lisp"; char c[]="Basic"; char *p[4]; p[0]=a; p[1]=b; p[2]=c; p[3]=NULL; …….. } 或: { char *p[4]; p[0]= "Fortran"; p[1]= "Lisp"; p[2]= "Basic"; p[3]=NULL; 初始化: main() { char *p[]={"Fortran", "Lisp", "Basic",NULL}; …….. } L i s p \0 F o r t r a n \0 B a s i c \0 p[0] p[1] p[2] p[3]

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

for(j=0;j<3;j++,pb[i]++) printf("b[%d][%d]:%2d\n",i,j,*pb[i]); } 例 用指针数组处理二维数组 main() { int b[2][3],*pb[2]; int i,j; for(i=0;i<2;i++) for(j=0;j<3;j++) b[i][j]=(i+1)*(j+1); pb[0]=b[0]; pb[1]=b[1]; 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] int b[2][3] 1 2 3 4 6 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)

例 对字符串排序（简单选择排序） k k j j j j i=0 main() 例 对字符串排序（简单选择排序） main() { void sort(char *name[],int n), print(char *name[],int n); char *name[]={"Follow me","BASIC", "Great Wall","FORTRAN","Computer "}; int n=5; sort(name,n); print(name,n); } void sort(char *name[],int n) { char *temp; int i,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] name Great Wall FORTRAN Computer Follow me BASIC k k j j j j i=0

例 对字符串排序（简单选择排序） k j k j k j i=1 main() 例 对字符串排序（简单选择排序） main() { void sort(char *name[],int n), print(char *name[],int n); char *name[]={"Follow me","BASIC", "Great Wall","FORTRAN","Computer "}; int n=5; sort(name,n); print(name,n); } void sort(char *name[],int n) { char *temp; int i,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 name[0] Follow me k name[1] BASIC j name[2] Great Wall k j name[3] FORTRAN k j name[4] Computer i=1

例 对字符串排序（简单选择排序） k k j j i=2 main() 例 对字符串排序（简单选择排序） main() { void sort(char *name[],int n), print(char *name[],int n); char *name[]={"Follow me","BASIC", "Great Wall","FORTRAN","Computer "}; int n=5; sort(name,n); print(name,n); } void sort(char *name[],int n) { char *temp; int i,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 name[0] Follow me name[1] BASIC k name[2] Great Wall k j name[3] FORTRAN j name[4] Computer i=2

例 对字符串排序（简单选择排序） k k j i=3 main() 例 对字符串排序（简单选择排序） main() { void sort(char *name[],int n), print(char *name[],int n); char *name[]={"Follow me","BASIC", "Great Wall","FORTRAN","Computer "}; int n=5; sort(name,n); print(name,n); } void sort(char *name[],int n) { char *temp; int i,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 name[0] Follow me name[1] BASIC name[2] Great Wall k name[3] FORTRAN k j name[4] Computer i=3

例 对字符串排序（简单选择排序） main() 例 对字符串排序（简单选择排序） main() { void sort(char *name[],int n), print(char *name[],int n); char *name[]={"Follow me","BASIC", "Great Wall","FORTRAN","Computer "}; int n=5; sort(name,n); print(name,n); } void sort(char *name[],int n) { char *temp; int i,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 name[0] Follow me name[1] BASIC name[2] Great Wall name[3] FORTRAN name[4] Computer

多级指针 定义: 指向指针的指针 一级指针:指针变量中存放目标变量的地址 例 int *p; int i=3; p=&i; *p=5; 单级间接寻址 二级指针:指针变量中存放一级指针变量的地址 例 int **p1; int *p2; int i=3; p2=&i; p1=&p2; **p1=5; p1 &p2 &i 3 P2(指针变量) i(整型变量) 二级指针 一级指针 目标变量 二级间接寻址

p=&i; ()//p是二级指针，不能用变量地址为其赋值 定义形式：[存储类型] 数据类型 **指针名； 如 char **p; *p是p间接指向对象的地址 **p是p间接指向对象的值 指针本身的存储类型 最终目标变量的数据类型 例 int i=3; int *p1; int **p2; p1=&i; p2=&p1; **p=5; i p1 p2 3 &i &p1 **p2, *p1 *p2 例 int i, **p; p=&i; ()//p是二级指针，不能用变量地址为其赋值 多级指针 例 三级指针 int ***p; 四级指针 char ****p;

#include <stdio.h> void swap(int *r,int *s) { int *t; t=r; r=s; 例 一级指针与二级指针 #include <stdio.h> void swap(int *r,int *s) { int *t; t=r; r=s; s=t; } main() { int a=1,b=2,*p,*q; p=&a; q=&b; swap(p,q); printf("%d,%d\n",*p,*q); 2000 2008 200A 2002 2004 2006 1 2 变量a 变量b (main) 指针变量p 指针变量q COPY 指针变量s 指针变量r (swap) 指针变量t 2002 2000 2002 2000 2000

#include <stdio.h> void swap(int *r,int *s) { int *t; t=r; r=s; 例 一级指针与二级指针 #include <stdio.h> void swap(int *r,int *s) { int *t; t=r; r=s; s=t; } main() { int a=1,b=2,*p,*q; p=&a; q=&b; swap(p,q); printf("%d,%d\n",*p,*q); 2000 2008 200A 2002 2004 2006 1 2 变量a 变量b (main) 指针变量p 指针变量q 输出: 1,2

#include <stdio.h> void swap(int *r,int *s) { int *t; t=r; r=s; b p q 例 一级指针与二级指针 #include <stdio.h> void swap(int *r,int *s) { int *t; t=r; r=s; s=t; } main() { int a=1,b=2,*p,*q; p=&a; q=&b; swap(p,q); printf("%d,%d\n",*p,*q); a b p q r s a b p q s r a b p q 输出: 1,2

#include <stdio.h> void swap(int **r,int **s) { int *t; t=*r; 例 一级指针与二级指针 #include <stdio.h> void swap(int **r,int **s) { int *t; t=*r; *r=*s; *s=t; } main() { int a=1,b=2,*p,*q; p=&a; q=&b; swap(&p,&q); printf("%d,%d\n",*p,*q); 2000 2008 200A 2002 2004 2006 1 2 变量a 变量b (main) 指针变量p 指针变量q 2002 COPY 2000 二级指针s 二级指针r (swap) 指针变量t 2006 2004 2000

#include <stdio.h> void swap(int **r,int **s) { int *t; t=*r; 例 一级指针与二级指针 #include <stdio.h> void swap(int **r,int **s) { int *t; t=*r; *r=*s; *s=t; } main() { int a=1,b=2,*p,*q; p=&a; q=&b; swap(&p,&q); printf("%d,%d\n",*p,*q); 2000 2008 200A 2002 2004 2006 1 2 变量a 变量b (main) 指针变量p 指针变量q 2002 2000 输出: 2,1

#include <stdio.h> void swap(int **r,int **s) { int *t; t=*r; 例 一级指针与二级指针 a b p q #include <stdio.h> void swap(int **r,int **s) { int *t; t=*r; *r=*s; *s=t; } main() { int a=1,b=2,*p,*q; p=&a; q=&b; swap(&p,&q); printf("%d,%d\n",*p,*q); a b r s p q a b r s p q b a p q 输出: 2,1

char *name[]={"hello","good","world","bye",""}; p=name+1; 例 用二级指针处理字符串 用*p可输出地址(%o或%x), 也可用它输出字符串(%s) #define NULL 0 void main() { 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] world bye \0 hello good name p *(p++) p 运行结果： 644 : good bye

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

C:\TC> copy[.exe] source.c temp.c 命令行参数 命令行：在操作系统状态下，为执行某个程序而键入的一行字符 命令行一般形式：命令名 参数1 参数2………参数n C:\TC> copy[.exe] source.c temp.c 带参数的main函数形式： 有3个字符串参数的命令行 main(int argc, char *argv[]) { ……… } 命令行参数传递 命令行实参 main(形参) 系统自动调用 main函数时传递 命令行中参数个数 形参名任意 元素指向命令行参数 中各字符串首地址 第一个参数: main所在的可执行文件名

main(int argc, char *argv[]) { while(argc-->0) 例 输出命令行参数 main(int argc, char *argv[]) { while(argc-->0) printf("%s\n",*argv++); } /*test.c*/ main(int argc, char *argv[]) { while(argc>1) { ++argv; printf("%s\n",*argv); --argc; } argv[0] argv[1] argv[2] char *argv[] world test hello argv argc=3 1. 编译、链接test.c，生成可执行文件test.exe 2. 在DOS状态下运行(test.exe所在路径下） 例如： C:\TC> test[.exe] hello world! 运行结果：hello world! 运行结果：test hello world!

指针的数据类型 定义 含义 int i; 定义整型变量i p为指向整型数据的指针变量 int *p; int a[n]; int *p[n]; int (*p)[n]; int f(); int *p(); int (*p)(); int **p; 定义整型变量i p为指向整型数据的指针变量 定义含n个元素的整型数组a n个指向整型数据的指针变量组成的指针数组p p为指向含n个元素的一维整型数组的指针变量 f为返回整型数的函数 p为返回指针的函数，该指针指向一个整型数据 p为指向函数的指针变量，该函数返回整型数 p为指针变量，它指向一个指向整型数据的指针变量 指针的数据类型

例 下列定义的含义 （1）int *p[3]; （2）int (*p)[3]; （3）int *p(int); （4）int (*p)(int); （5）int *(*p)(int); （6）int (*p[3])(int); （7）int *(*p[3])(int); 指针数组 指向一维数组的指针 返回指针的函数 指向函数的指针，函数返回int型变量 指向函数的指针，函数返回int 型指针 函数指针数组，函数返回int型变量 函数指针数组，函数返回int型指针