C程序设计
南京师范大学
地图学与地理信息系统 04级
专业选修课
主讲教师, 汪闽
第九章 指针
9.1 指针的概念
9.2 指针变量
9.3 指向数组的指针变量
9.4 指针与字符串
9.6 指针数组与多级指针
9.5 指针与函数
9.7 命令行参数
?前言
C程序设计中使用指针可以,
– 使程序简洁、紧凑、高效
– 有效地表示复杂的数据结构
– 动态分配内存
– 得到多于一个的函数返回值
9.1.1变量与地址
程序中, int i;
float k;
内存中每个字节有一个编号 -----地址
…...
…...
2000
2001
2002
2005
内存
0
2003
i
k
编译或函数调用时为其分配内存单元
变量 是对程序中数据
存储空间的抽象
9.1 指针的概念
…...
…...
2000
2004
2006
2005
整型变量 i
10
变量 i_pointer
2001
2002
2003
指针：一个变量的地址
指针变量：专门存放变量地址的变量叫 ~
2000
指针
指针变量
变量的 内容变量的
地址
指针变量
变量
变量地址 (指针 )
变量值
指向 地址存入
指针变量
9.1.2指针与指针变量
? 含义
含义, 取变量的地址
单目运算符
优先级, 2
结合性,自右向左
含义, 取指针所指向变量的内容
单目运算符
优先级, 2
结合性,自右向左
两者关系：互为 逆运算
理解
…...
…...
2000
2004
2006
2005
整型变量 i
10
变量 i_pointer
2001
2002
2003
2000 指针变量
i_pointer-----指针变量，它的内容是地址量
*i_pointer----指针的 目标变量,它的内容是数据
&i_pointer---指针变量占用内存的地址
2000 10
i_pointer *i_pointer
&i_pointer
i
i_pointer &i &(*i_pointer)
i *i_pointer *(&i)
i_pointer = &i = &(*i_pointer)
i = *i_pointer = *(&i)
9.1.3 &与 *运算符
? 直接访问：按变量地址存取变量值
? 间接访问：通过存放变量地址的变量去访问变量
例 i=3; -----直接访问
指针变量
…...
…...
2000
2004
2006
2005
整型变量 i
10
变量 i_pointer
2001
2002
2003
2000
3
例 *i_pointer=20; -----间接访问
20
9.1.4直接访问与间接访问
指针变量
…...
…...
2000
2004
2006
2005
整型变量 i
10
变量 i_pointer
2001
2002
2003
2000
整型变量 k
例 k=i; --直接访问
k=*i_pointer; --间接访问
10
例
例子图解
9.2.1指针变量 与其 所指向的变量 之间的关系
指针变量的定义
一般形式,[存储类型 ] 数据类型 *指针名；
3
变量 i
2000
i_pointer
*i_pointer
i *i_pointer
&i i_pointer
i=3; *i_pointer=3
变量
合法标识符指针变量本身的存储类型 指针的目标变量的数据类型 表示定义指针变量 不是‘ *’运算符
例 int *p1,*p2;
float *q ;
static char *name;
注意：
1,int *p1,*p2; 与 int *p1,p2;
2、指针变量名是 p1,p2,不是 *p1,*p2
3、指针变量只能指向定义时所规定类型的变量
4、指针变量定义后,变量值不确定,应用前必须先赋值
9.2 指针变量
一般形式,[存储类型 ] 数据类型 *指针名 =初始地址值 ；
赋给指针变量，
不是赋给目标变量
例 int i;
int *p=&i; 变量必须 已说明过
类型 应一致
例 int *p=&i;
int i;
例 int i;
int *p=&i;
int *q=p; 用已初始化指针变量作初值
例 main( )
{ int i;
static int *p=&i;
..............
} (?)
不能用 auto变量的地址
去初始化 static型指针
9.2.2指针变量的初始化
例 main( )
{ int i=10;
int *p;
*p=i;
printf(“%d”,*p);
}
危险！
例 main( )
{ int i=10,k;
int *p;
p=&k;
*p=i;
printf(“%d”,*p);
}
…...
…...
2000
2004
2006
2005
整型变量 i
10
指针变量 p
2001
2002
2003
随机
指针变量必须 先赋值,再使用
零指针,(空指针 )
定义,指针变量值为零
表示,int * p=0;
p指向地址为 0的单元,
系统保证该单元不作它用
表示指针变量值 没有意义
#define NULL 0
int *p=NULL:
p=NULL与未对 p赋值不同
用途,
避免指针变量的非法引用
在程序中常作为 状态 比较
例 int *p;
......
while(p!=NULL)
{,..…
}
void *类型指针
表示, void *p;
使用时要进行 强制类型转换
例 char *p1;
void *p2;
p1=(char *)p2;
p2=(void *)p1;
表示不指定 p是指向哪一种
类型数据的指针变量
9.2.3 零指针与空类型指针
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=9
max=9,min=5
…...
…...
指针变量 p1
指针变量 p
2000
2008
2002
2004
2006
指针变量 p2
整型变量 b
整型变量 a5
2006
9
2008
2006
2008
2006
例 输入两个数，并使其从大到小输出
特点,共享内存,“双向, 传递
swap(int x,int y)
{ int temp;
temp=x;
x=y;
y=temp;
}
main()
{ int a,b;
scanf("%d,%d",&a,&b);
if(a<b) swap(a,b);
printf("\n%d,%d\n",a,b);
}
例 将数从大到小输出 …...
…...
2000
2008
200A
2002
2004
2006
5 变量 a变量 b
(main)
9
变量 temp
变量 y
变量 x(swap)
5
5
95
9
COPY
9.2.4指针变量作为函数参数 ——地址传递
特点,共享内存,“双向, 传递
swap(int x,int y)
{ int temp;
temp=x;
x=y;
y=temp;
}
main()
{ int a,b;
scanf("%d,%d",&a,&b);
if(a<b) swap(a,b);
printf("\n%d,%d\n",a,b);
}
例 将数从大到小输出
值传递
…...
…...
2000
2008
200A
2002
2004
2006
5 变量 a变量 b
(main)
9
运行结果,5,9
swap(int *p1,int *p2)
{ int p;
p=*p1;
*p1=*p2;
*p2=p;
}
main()
{ int a,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);
}
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型变量 a
整型变量 b
(main)
指针 pointer_1
指针 pointer_220002002
(swap) 指针 p1
指针 p2
整型 p
5
9
2000
2002
COPY
5
例 将数从大到小输出
swap(int *p1,int *p2)
{ int p;
p=*p1;
*p1=*p2;
*p2=p;
}
main()
{ int a,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);
}
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型变量 a
整型变量 b
(main)
指针 pointer_1
指针 pointer_220002002
5
9
运行结果,9,5
地址传递
例 将数从大到小输出（ 1）
swap(int *p1,int *p2)
{ int *p;
*p=*p1;
*p1=*p2;
*p2=*p;
}
main()
{ int a,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
编译警告！
结果不对！
int x;
int *p=&x;x;
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型变量 a
整型变量 b
(main)
指针 pointer_1
指针 pointer_220002002
9
9
2000
2002
COPY (swap) 指针 p1
指针 p2
指针 p****
假设 2000
指针变量在使用前
必须赋值！
例 将数从大到小输出 （ 2）
/*ch9_32.c*/
swap(int x,int y)
{ int t;
t=x; x=y; y=t;
}
main()
{ int a,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
值传递
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型 a
整型 b
(main)
pointer_1
pointer_220002002
9
COPY (swap) 整型 x
整型 b
整型 t55
59
例 将数从大到小输出（ 3）
运行结果,5,9
swap(int *p1,int *p2)
{ int *p;
p=p1;
p1=p2;
p2=p;
}
main()
{ int a,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("%d,%d",*pointer_1,*pointer_2);
}
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型 a
整型 b
(main)
pointer_1
pointer_220002002
2000
2002
COPY (swap)
指针 p1
指针 p2
指针 p****2000
地址传递
2000
2002
例 将数从大到小输出（ 4）
9.3.1指向数组元素的指针变量
例 int array[10];
int *p;
p=&array[0]; //? p=array;
或 int *p=&array[0];
或 int *p=array;
array[0]
array[1]
array[2]
array[3]
array[9]
...
整型指针 p &array[0]
p
数组名 是表示数组 首地 址的 地址常量
9.3 指向数组的指针变量
?指针变量的赋值运算
p=&a; (将变量 a地址 ?p)
p=array; (将数组 array首地址 ?p)
p=&array[i]; (将数组元素地址 ?p)
p1=p2; (指针变量 p2值 ?p1)
不能把一个整数 ?p,也不能把 p的值 ?整型
变量
如 int i,*p;
p=1000; (?)
i=p; (?)
指针变量与其指向的变量具有相同 数据类型
9.3.2 指针的运算
p?i ? p ?i?d (i为整型数,d为 p指向的变量所占字节
数 )
p++,p--,p+i,p-i,p+=i,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]
例 int a[10];
int *p=&a[2];
p++;
*p=1;
例 int a[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数组p
p+1,a+1
p+i,a+i
p+9,a+9
1
?指针的
算术运算
若 p1和 p2指向同一数组，则
p1<p2 表示 p1指的元素在前
p1>p2 表示 p1指的元素在后
p1==p2 表示 p1与 p2指向同一元素
若 p1与 p2不指向同一数组，比较无意义
p==NULL或 p!=NULL
?指针变量的关系运算
a[0]
a[1]
a[2]
a[3]
a[9]
...
a
a+9
a+1
a+2
地址 元素
下标法
a[0]
a[1]
a[2]
a[9]
a[0]
a[1]
a[2]
a[3]
a[9]
...
p
p+9
p+1
p+2
地址 元素
指针法
*p
*(p+1)
*(p+2)
*(p+9)
[] 变址运算符
a[i] ? *(a+i)
a[i] ? p[i] ? *(p+i) ?*(a+i)
*a
*(a+1)
*(a+2)
*(a+9)
p[0]
p[1]
p[2]
p[9]
?指针变量操作数组
a[0]
a[1]
a[2]
a[3]
a[4]
main()
{ int a[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]);
}
1
2
3
4
5
pa
例 数组元素的引用方法
例 int a[]={1,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) (?)
例 void main()
{ int a []={5,8,7,6,2,7,3};
int y,*p=&a[1];
y=(*--p)++;
printf(“%d,,y);
printf(“%d”,a[0]);
}
输出,5 6
p
p 5
8
7
6
2
7
3
0
1
2
3
4
5
6
a
6
例 注意指针变量的运算
main()
{ int i,*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;
p
p 5
8
7
6
2
7
3
0
1
2
3
4
5
6
a
p
p
p
p
p
p
指针变量可以指到 数组后 的内存单元
例 注意指针的当前值
数组名作函数参数，是 地址传递
数组名作函数参数，实参与形参的对应关系
实参 形参
数组名
指针变量
数组名
指针变量
数组名
数组名
指针变量
指针变量
9.3.3 数组名作函数参数
i j
3 7 9 11 0 6 7 5 4 2
0 1 2 3 4 5 6 7 8 9
i ji ji jji
117 6 05 94 72 3
实参与形参均用数组
void inv(int x[],int n)
{ int t,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()
{ int i,a[10]={3,7,9,11,0,6,7,5,4,2};
inv(a,10);
printf("The array has been reverted:\n");
for(i=0;i<10;i++)
printf("%d,",a[i]);
printf("\n");
}
m=4
例 将数组 a中的 n个整数按相反顺序存放（ 1）
void inv(int *x,int n)
{ int t,*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()
{ int i,a[10]={3,7,9,11,0,6,7,5,4,2};
inv(a,10);
printf("The array has been reverted:\n");
for(i=0;i<10;i++)
printf("%d,",a[i]);
printf("\n");
}
实参用数组,形参用指针变量
3
7
9
11
0
6
7
5
4
2
a[0]
a[1]
a[2]
a[3]
a[4]
a[5]
a[6]
a[7]
a[8]
a[9]
x
p=x+m
a数组
6
0
7
11
5
9
4
7
2
3
i
j
i
j
i
j
ji
j
i
例 将数组 a中的 n个整数按相反顺序存放（ 2）
void inv(int *x,int n)
{ int t,*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()
{ int i,a[10],*p=a;
for(i=0;i<10;i++,p++)
scanf("%d",p);
p=a; inv(p,10);
printf("The array has been reverted:\n");
for(p=a;p<a+10;p++)
printf("%d",*p);
}
实参与形参均用指针变量
例 将数组 a中的 n个整数按相反顺序存放（ 3）
void inv(int x[],int n)
{ int t,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()
{ int i,a[10],*p=a;
for(i=0;i<10;i++,p++)
scanf("%d",p);
p=a; inv(p,10);
printf("The array has been reverted:\n");
for(p=arr;p<arr+10;p++)
printf("%d ",*p);
}
实参用指针变量,形参用数组
例 将数组 a中的 n个整数按相反顺序存放（ 4）
int *p 与 int q[10]
数组名是指针（地址） 常量
p=q; p+i 是 q[i]的地址
数组元素的表示方法,下标法 和 指针法, 即若 p=q,
则 p[i] ? q[i] ? *(p+i) ? *(q+i)
形参数组 实质上是 指针变量,即 int q[ ] ? int *q
在定义指针变量（不是形参）时,不能把 int *p 写成 int p[];
系统只给 p分配能保存一个指针值的内存区 (一般 2字节
）；而给 q分配 2*10字节的内存区
9.3.4 一级指针变量与一维数组的关系 (小节 )
9.3.5.1 对于一维数组 (复习总结 )
（ 1）数组名 array表示数组的首地址，即 array[0]的
地址；
（ 2）数组名 array是地址 常量
（ 3） array+i是元素 array[i]的地址
（ 4） array[i] ? *(array+i)
array int array[10];
9.3.5 指针与二维数组
对于二维数组：
（ 1） a是数组名，
包含三个元素
a[0],a[1],a[2]
（ 2）每个元素 a[i]
又是一个一维
数组，包含 4个
元素
a
a+1
a+2
*(*(a+0)+1)
*(a[0]+1)int a[3][4];
a[0]
a[1]
a[2]
2000
2008
2016
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]+1
a[1]+1
a[2]+1
*(a+0)+1
*(a+1)+1
*(a+2)+1
9.3.5.2 二维数组, 行指针与列指针（ 1）
– 对二维数组 int a[3][4],有
?a-----二维数组的首地址，即第 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列元素地址，指向列
int a[3][4];
a[0]
a[1]
a[2]
2000
2008
2016
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
a+1
a+2
9.3.5.2 行指针与列指针（ 2）
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]
二维数组元素表示形式：
（ 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+2
9.3.5.2 行指针与列指针（ 3）
表示形式 含义 地址
a 二维数组名，数组首地址
a[0],*(a+0),*a 第 0行第 0列元素地址
a+1 第 1行首地址
a[1],*(a+1) 第 1行第 0列元素地址
a[1]+2,*(a+1)+2,&a[1][2] 第 1行第 2列元素地址
*(a[1]+2),*(*(a+1)+2),a[1][2] 第 1行第 2列元素值
2000
2000
2008
2008
2012
13
表格说明
– 指向二维数组 元素 的指针变量
例 指向二维数组元素的指针变量
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=*a;
p=&a[0][0];
p=*(a+0);
p=a;
p=*a;
p=&a[0][0];
p=(int *)a;
p=a;
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
9.3.5.3 二维数组的指针变量
?定义形式,数据类型 (*指针名 )[一维数组长度 ];
例 int (*p)[4];
( )不能少
int (*p)[4]与 int *p[4]不同
p的值是一维数组的
首地址,p是 行指针
可让 p指向二维数组某一行
如 int a[3][4],(*p)[4]=a;
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[0]+1或 *p+1
p[1]+2或 *(p+1)+2
*(*p+1)或 (*p)[1]
*(*(p+1)+2)
一维数组指针变量数组长度和
二维数组 列数 必须相同
─指向一维数组的指针变量 (行指针 )
main()
{ int a[3][4]={{1,2,3,4},{3,4,5,6},{5,6,7,8}};
int i;
int (*p)[4]=a,*q=a[0];
for(i=0;i<3;i++)
{ if(i==0)
(*p)[i+i/2]=*q+1;
else
p++,++q;
}
for(i=0;i<3;i++)
printf("%d,",a[i][i]);
printf("%d,%d\n",*((int *)p),*q);
}
运行结果,2,4,7,5,3
1 2 3 4
3 4 5 6
5 6 7 8
p
q
2p
q
p
q
例 二维数组与指针运算
– 用指向变量的指针变量
– 用指向一维数组的指针变量
– 用二维数组名
实参 形参
数组名 int x[][4]
指针变量 int (*q)[4]
数组名 int x[][4]
指针变量 int (*q)[4]
数组名 a
数组名 a
指针变量 p1
指针变量 p1
若 int a[3][4]; int (*p1)[4]=a; int *p2=a[0];
指针变量 p2 指针变量 int *q
9.3.5.4 二维数组的指针作函数参数
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);
}
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));
}
列指针
行指针
函数说明
float p[][4]
65 52 79 60
80 87 90 81
90 99 100 98
p
p
? p[n][i]
例 3个学生各学 4门课，计算总平均分，并输出第 n个学生成绩
9.4 指针与字符串
– 字符串表示形式
? 用字符数组实现
例 main( )
{ char string[]=“I love China!”;
printf(“%s\n”,string);
printf(“%s\n”,string+7);
}
I
l
o
v
e
C
h
i
string[0]
string[1]
string[2]
string[3]
string[4]
string[5]
string[6]
string[7]
string[8]
string[9]
string
string[10]
string[11]
string[12]
string[13]
n
!
a
\0
例 main( )
{ char *string=“I love China!”;
printf(“%s\n”,string);
string+=7;
while(*string)
{ putchar(string[0]);
string++;
}
}
I
l
o
v
e
C
h
i
string
n
!
a
\0
字符指针 初始化,把字符串 首地址 赋给 string
? char *string;
string=“I love China!”;
string
*string!=0
用字符指针实现
例 用函数调用实现字符串复制
（ 1）用字符数组作参数
（ 2）用字符指针变量作参数
a
I
a
m
a
t
e
a
c
e
h
\0
r
.
from
a b
y
u
a
r
a
s
u
t
n
d
e
to
b
o
e
t
.
\0
I
a
a
e
c
e
h
\0
r
.
t
.
\0
m
t
a
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);
}
字符串指针作函数参数
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
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}; (?)
scanf(“%s”,str);
printf(“%s”,str);
gets(str);
puts(str);
字符串与数组关系
9.5.1函数指针：函数在编译时被分配的入口地址,用
函数名表示
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()不同
9.5 指针与函数
例 用函数指针变量作参数，求最大值、最小值和两数之和
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);
}
9.5.2 用函数指针变量作函数参数
?函数定义形式：
类型标识符 *函数名 (参数表 );
例 int *f(int x,int y)
例 指针函数实现：有若干学生成绩，要求输入学生序号后，
能输出其全部成绩
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);
}
pointer
pointer+1
34 78 90 66
56 89 67 88
60 70 80 90
score数组
p p p p
9.5.3 返回指针值的函数
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
2
3
指针变量 y
指针变量 x(f1)
2002
2000
COPY
变量 a
变量 b
(main)
指针变量 p**
例 写一个函数，求两个 int型变量中居于较大值的变量的地址（ 1）
…...
…...
2000
2008
200A
2002
2004
2006
2 变量 a变量 b
(main)
3 指针变量 p
**2002
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);
}
例 写一个函数，求两个 int型变量中居于较大值的变量的地址（ 2）
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
3
变量 y
变量 x(f3)
3
2
COPY
变量 a
变量 b
(main)
指针变量 p**
例 写一个函数，求两个 int型变量中居于较大值的变量的地址（ 3）
不能返回 形参 或 局部变量
的 地址 作函数返回值
…...
…...
2000
2008
200A
2002
2004
2006
2 变量 a变量 b
(main)
3 指针变量 p
**200A
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);
}
例 写一个函数，求两个 int型变量中居于较大值的变量的地址（ 4）
用于处理二维数组或多个字符串
– 指针数组
? 定义：数组中的元素为指针变量
? 定义形式,[存储类型 ] 数据类型 *数组名 [数组长度说明 ]；
例 int *p[4];
指针所指向变量的数据类型指针本身的存储类型区分 int *p[4]与 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
2
4
6
初始化,
main()
{ int b[2][3],*pb[ ]={b[0],b[1]};
……..
}
int *pb[2]
pb[0]
pb[1]
int b[2][3]
1
2
3
2
4
6
9.6 指针数组和多级指针
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] 0
赋值,
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;
……..
}
或,
main()
{ char *p[4];
p[0]= "Fortran";
p[1]= "Lisp";
p[2]= "Basic";
p[3]=NULL;
……..
}
初始化,
main()
{ char *p[]={"Fortran","Lisp","Basic",NULL};
……..
}
i s \
F r t r a \
a s i c \
[0]
[1]
[2]
[3]
指针数组赋值与初始化
char name[5][9]={“gain”,“much”,“stronger”,“point”,“bye”};
char *name[5]={“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
name[0]
name[1]
name[2]
name[3]
name[4] 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
b y e \0
二维数组存储空间固定
字符指针数组相当于 可变列长 的二维数组
指针数组元素的作用相当于二维数组的行名
但指针数组中元素是指针变量
二维数组的行名是 地址常量
二维数组与指针数组区别,
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(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]
int b[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)
1
2
3
2
4
6
例 用指针数组处理二维数组
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
jk
j
j
j
i=0
例 对字符串排序（简单选择排序）图解 1
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
BASICk
k
j
j
j
i=1
k
例 对字符串排序（简单选择排序）图解 2
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
BASICk
k j
j
i=2
例 对字符串排序（简单选择排序）图解 3
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
i=3
例 对字符串排序（简单选择排序）图解 4
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
例 对字符串排序（简单选择排序）图解 5
? 定义, 指向指针的指针
? 一级指针,指针变量中存放目标变量的地址
p1
&p2 &i 3
P2(指针变量 ) i(整型变量 )例 int **p1;
int *p2;
int i=3;
p2=&i;
p1=&p2;
**p1=5;
二级指针,指针变量中存放一级指针变量的地址
例 int *p;
int i=3;
p=&i;
*p=5;
&i 3
P(指针变量 ) i(整型变量 )
一级指针 单级间接寻址
二级指针 一级指针 目标变量
二级间接寻址
多级指针
定义形式,[存储类型 ] 数据类型 **指针名；
如 char **p;
例 int i,**p;
p=&i; (?)//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 ***p;
四级指针 char ****p;
多级指针定义形式
2000
2008
200A
2002
2004
2006
1
2
变量 a
变量 b
(main)
指针变量 p2000
指针变量 q2002
#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);
}
2002
2000
COPY
指针变量 s
指针变量 r(swap)
指针变量 t2000
2002
2000
例 一级指针与二级指针图解 1
2000
2008
200A
2002
2004
2006
1
2
变量 a
变量 b
(main)
指针变量 p2000
指针变量 q2002
#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);
} 输出, 1,2
例 一级指针与二级指针图解 2
#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
a
b
p
q
r
s
a
b
p
q
s
r
a
b
p
q
输出, 1,2
例 一级指针与二级指针图解 3
用一级指针
达不到要求 !
#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)
指针变量 p2000
指针变量 q2002
2006
2004
COPY
二级指针 s
二级指针 r(swap)
指针变量 t
2000
2002
2000
例 一级指针与二级指针图解 4
#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)
指针变量 p2000
指针变量 q200220002002
输出, 2,1
例 一级指针与二级指针图解 5
#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
b
a
p
q
a
b
r
s
p
q
a
b
r
s
p
q
输出, 2,1
例 一级指针与二级指针图解 6
? 命令行：在操作系统状态下，为执行某个程序而键入
的一行字符
? 命令行一般形式,命令名 参数 1 参数 2……… 参数 n
main(int argc,char *argv[])
{ ………
}
命令行参数传递
带参数的 main函数形式：
C:\TC> copy[.exe] source.c temp.c
有 3个字符串参数的命令行
命令行中参数个数 元素指向命令行参数
中各字符串首地址
形参名任意
命令行 实参 main(形参 )
系统自动调用
main函数时传递
第一个参数, main所在的 可执行文件名
9.7 命令行参数
定义 含义
int i;
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为指针变量，它指向一个指向整型数据的指针变量
指针的数据类型
南京师范大学
地图学与地理信息系统 04级
专业选修课
主讲教师, 汪闽
第九章 指针
9.1 指针的概念
9.2 指针变量
9.3 指向数组的指针变量
9.4 指针与字符串
9.6 指针数组与多级指针
9.5 指针与函数
9.7 命令行参数
?前言
C程序设计中使用指针可以,
– 使程序简洁、紧凑、高效
– 有效地表示复杂的数据结构
– 动态分配内存
– 得到多于一个的函数返回值
9.1.1变量与地址
程序中, int i;
float k;
内存中每个字节有一个编号 -----地址
…...
…...
2000
2001
2002
2005
内存
0
2003
i
k
编译或函数调用时为其分配内存单元
变量 是对程序中数据
存储空间的抽象
9.1 指针的概念
…...
…...
2000
2004
2006
2005
整型变量 i
10
变量 i_pointer
2001
2002
2003
指针：一个变量的地址
指针变量：专门存放变量地址的变量叫 ~
2000
指针
指针变量
变量的 内容变量的
地址
指针变量
变量
变量地址 (指针 )
变量值
指向 地址存入
指针变量
9.1.2指针与指针变量
? 含义
含义, 取变量的地址
单目运算符
优先级, 2
结合性,自右向左
含义, 取指针所指向变量的内容
单目运算符
优先级, 2
结合性,自右向左
两者关系：互为 逆运算
理解
…...
…...
2000
2004
2006
2005
整型变量 i
10
变量 i_pointer
2001
2002
2003
2000 指针变量
i_pointer-----指针变量，它的内容是地址量
*i_pointer----指针的 目标变量,它的内容是数据
&i_pointer---指针变量占用内存的地址
2000 10
i_pointer *i_pointer
&i_pointer
i
i_pointer &i &(*i_pointer)
i *i_pointer *(&i)
i_pointer = &i = &(*i_pointer)
i = *i_pointer = *(&i)
9.1.3 &与 *运算符
? 直接访问：按变量地址存取变量值
? 间接访问：通过存放变量地址的变量去访问变量
例 i=3; -----直接访问
指针变量
…...
…...
2000
2004
2006
2005
整型变量 i
10
变量 i_pointer
2001
2002
2003
2000
3
例 *i_pointer=20; -----间接访问
20
9.1.4直接访问与间接访问
指针变量
…...
…...
2000
2004
2006
2005
整型变量 i
10
变量 i_pointer
2001
2002
2003
2000
整型变量 k
例 k=i; --直接访问
k=*i_pointer; --间接访问
10
例
例子图解
9.2.1指针变量 与其 所指向的变量 之间的关系
指针变量的定义
一般形式,[存储类型 ] 数据类型 *指针名；
3
变量 i
2000
i_pointer
*i_pointer
i *i_pointer
&i i_pointer
i=3; *i_pointer=3
变量
合法标识符指针变量本身的存储类型 指针的目标变量的数据类型 表示定义指针变量 不是‘ *’运算符
例 int *p1,*p2;
float *q ;
static char *name;
注意：
1,int *p1,*p2; 与 int *p1,p2;
2、指针变量名是 p1,p2,不是 *p1,*p2
3、指针变量只能指向定义时所规定类型的变量
4、指针变量定义后,变量值不确定,应用前必须先赋值
9.2 指针变量
一般形式,[存储类型 ] 数据类型 *指针名 =初始地址值 ；
赋给指针变量，
不是赋给目标变量
例 int i;
int *p=&i; 变量必须 已说明过
类型 应一致
例 int *p=&i;
int i;
例 int i;
int *p=&i;
int *q=p; 用已初始化指针变量作初值
例 main( )
{ int i;
static int *p=&i;
..............
} (?)
不能用 auto变量的地址
去初始化 static型指针
9.2.2指针变量的初始化
例 main( )
{ int i=10;
int *p;
*p=i;
printf(“%d”,*p);
}
危险！
例 main( )
{ int i=10,k;
int *p;
p=&k;
*p=i;
printf(“%d”,*p);
}
…...
…...
2000
2004
2006
2005
整型变量 i
10
指针变量 p
2001
2002
2003
随机
指针变量必须 先赋值,再使用
零指针,(空指针 )
定义,指针变量值为零
表示,int * p=0;
p指向地址为 0的单元,
系统保证该单元不作它用
表示指针变量值 没有意义
#define NULL 0
int *p=NULL:
p=NULL与未对 p赋值不同
用途,
避免指针变量的非法引用
在程序中常作为 状态 比较
例 int *p;
......
while(p!=NULL)
{,..…
}
void *类型指针
表示, void *p;
使用时要进行 强制类型转换
例 char *p1;
void *p2;
p1=(char *)p2;
p2=(void *)p1;
表示不指定 p是指向哪一种
类型数据的指针变量
9.2.3 零指针与空类型指针
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=9
max=9,min=5
…...
…...
指针变量 p1
指针变量 p
2000
2008
2002
2004
2006
指针变量 p2
整型变量 b
整型变量 a5
2006
9
2008
2006
2008
2006
例 输入两个数，并使其从大到小输出
特点,共享内存,“双向, 传递
swap(int x,int y)
{ int temp;
temp=x;
x=y;
y=temp;
}
main()
{ int a,b;
scanf("%d,%d",&a,&b);
if(a<b) swap(a,b);
printf("\n%d,%d\n",a,b);
}
例 将数从大到小输出 …...
…...
2000
2008
200A
2002
2004
2006
5 变量 a变量 b
(main)
9
变量 temp
变量 y
变量 x(swap)
5
5
95
9
COPY
9.2.4指针变量作为函数参数 ——地址传递
特点,共享内存,“双向, 传递
swap(int x,int y)
{ int temp;
temp=x;
x=y;
y=temp;
}
main()
{ int a,b;
scanf("%d,%d",&a,&b);
if(a<b) swap(a,b);
printf("\n%d,%d\n",a,b);
}
例 将数从大到小输出
值传递
…...
…...
2000
2008
200A
2002
2004
2006
5 变量 a变量 b
(main)
9
运行结果,5,9
swap(int *p1,int *p2)
{ int p;
p=*p1;
*p1=*p2;
*p2=p;
}
main()
{ int a,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);
}
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型变量 a
整型变量 b
(main)
指针 pointer_1
指针 pointer_220002002
(swap) 指针 p1
指针 p2
整型 p
5
9
2000
2002
COPY
5
例 将数从大到小输出
swap(int *p1,int *p2)
{ int p;
p=*p1;
*p1=*p2;
*p2=p;
}
main()
{ int a,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);
}
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型变量 a
整型变量 b
(main)
指针 pointer_1
指针 pointer_220002002
5
9
运行结果,9,5
地址传递
例 将数从大到小输出（ 1）
swap(int *p1,int *p2)
{ int *p;
*p=*p1;
*p1=*p2;
*p2=*p;
}
main()
{ int a,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
编译警告！
结果不对！
int x;
int *p=&x;x;
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型变量 a
整型变量 b
(main)
指针 pointer_1
指针 pointer_220002002
9
9
2000
2002
COPY (swap) 指针 p1
指针 p2
指针 p****
假设 2000
指针变量在使用前
必须赋值！
例 将数从大到小输出 （ 2）
/*ch9_32.c*/
swap(int x,int y)
{ int t;
t=x; x=y; y=t;
}
main()
{ int a,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
值传递
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型 a
整型 b
(main)
pointer_1
pointer_220002002
9
COPY (swap) 整型 x
整型 b
整型 t55
59
例 将数从大到小输出（ 3）
运行结果,5,9
swap(int *p1,int *p2)
{ int *p;
p=p1;
p1=p2;
p2=p;
}
main()
{ int a,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("%d,%d",*pointer_1,*pointer_2);
}
…...
2000
2008
200A
2002
2004
2006
200C
200E
2010,..
5
9
整型 a
整型 b
(main)
pointer_1
pointer_220002002
2000
2002
COPY (swap)
指针 p1
指针 p2
指针 p****2000
地址传递
2000
2002
例 将数从大到小输出（ 4）
9.3.1指向数组元素的指针变量
例 int array[10];
int *p;
p=&array[0]; //? p=array;
或 int *p=&array[0];
或 int *p=array;
array[0]
array[1]
array[2]
array[3]
array[9]
...
整型指针 p &array[0]
p
数组名 是表示数组 首地 址的 地址常量
9.3 指向数组的指针变量
?指针变量的赋值运算
p=&a; (将变量 a地址 ?p)
p=array; (将数组 array首地址 ?p)
p=&array[i]; (将数组元素地址 ?p)
p1=p2; (指针变量 p2值 ?p1)
不能把一个整数 ?p,也不能把 p的值 ?整型
变量
如 int i,*p;
p=1000; (?)
i=p; (?)
指针变量与其指向的变量具有相同 数据类型
9.3.2 指针的运算
p?i ? p ?i?d (i为整型数,d为 p指向的变量所占字节
数 )
p++,p--,p+i,p-i,p+=i,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]
例 int a[10];
int *p=&a[2];
p++;
*p=1;
例 int a[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数组p
p+1,a+1
p+i,a+i
p+9,a+9
1
?指针的
算术运算
若 p1和 p2指向同一数组，则
p1<p2 表示 p1指的元素在前
p1>p2 表示 p1指的元素在后
p1==p2 表示 p1与 p2指向同一元素
若 p1与 p2不指向同一数组，比较无意义
p==NULL或 p!=NULL
?指针变量的关系运算
a[0]
a[1]
a[2]
a[3]
a[9]
...
a
a+9
a+1
a+2
地址 元素
下标法
a[0]
a[1]
a[2]
a[9]
a[0]
a[1]
a[2]
a[3]
a[9]
...
p
p+9
p+1
p+2
地址 元素
指针法
*p
*(p+1)
*(p+2)
*(p+9)
[] 变址运算符
a[i] ? *(a+i)
a[i] ? p[i] ? *(p+i) ?*(a+i)
*a
*(a+1)
*(a+2)
*(a+9)
p[0]
p[1]
p[2]
p[9]
?指针变量操作数组
a[0]
a[1]
a[2]
a[3]
a[4]
main()
{ int a[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]);
}
1
2
3
4
5
pa
例 数组元素的引用方法
例 int a[]={1,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) (?)
例 void main()
{ int a []={5,8,7,6,2,7,3};
int y,*p=&a[1];
y=(*--p)++;
printf(“%d,,y);
printf(“%d”,a[0]);
}
输出,5 6
p
p 5
8
7
6
2
7
3
0
1
2
3
4
5
6
a
6
例 注意指针变量的运算
main()
{ int i,*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;
p
p 5
8
7
6
2
7
3
0
1
2
3
4
5
6
a
p
p
p
p
p
p
指针变量可以指到 数组后 的内存单元
例 注意指针的当前值
数组名作函数参数，是 地址传递
数组名作函数参数，实参与形参的对应关系
实参 形参
数组名
指针变量
数组名
指针变量
数组名
数组名
指针变量
指针变量
9.3.3 数组名作函数参数
i j
3 7 9 11 0 6 7 5 4 2
0 1 2 3 4 5 6 7 8 9
i ji ji jji
117 6 05 94 72 3
实参与形参均用数组
void inv(int x[],int n)
{ int t,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()
{ int i,a[10]={3,7,9,11,0,6,7,5,4,2};
inv(a,10);
printf("The array has been reverted:\n");
for(i=0;i<10;i++)
printf("%d,",a[i]);
printf("\n");
}
m=4
例 将数组 a中的 n个整数按相反顺序存放（ 1）
void inv(int *x,int n)
{ int t,*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()
{ int i,a[10]={3,7,9,11,0,6,7,5,4,2};
inv(a,10);
printf("The array has been reverted:\n");
for(i=0;i<10;i++)
printf("%d,",a[i]);
printf("\n");
}
实参用数组,形参用指针变量
3
7
9
11
0
6
7
5
4
2
a[0]
a[1]
a[2]
a[3]
a[4]
a[5]
a[6]
a[7]
a[8]
a[9]
x
p=x+m
a数组
6
0
7
11
5
9
4
7
2
3
i
j
i
j
i
j
ji
j
i
例 将数组 a中的 n个整数按相反顺序存放（ 2）
void inv(int *x,int n)
{ int t,*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()
{ int i,a[10],*p=a;
for(i=0;i<10;i++,p++)
scanf("%d",p);
p=a; inv(p,10);
printf("The array has been reverted:\n");
for(p=a;p<a+10;p++)
printf("%d",*p);
}
实参与形参均用指针变量
例 将数组 a中的 n个整数按相反顺序存放（ 3）
void inv(int x[],int n)
{ int t,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()
{ int i,a[10],*p=a;
for(i=0;i<10;i++,p++)
scanf("%d",p);
p=a; inv(p,10);
printf("The array has been reverted:\n");
for(p=arr;p<arr+10;p++)
printf("%d ",*p);
}
实参用指针变量,形参用数组
例 将数组 a中的 n个整数按相反顺序存放（ 4）
int *p 与 int q[10]
数组名是指针（地址） 常量
p=q; p+i 是 q[i]的地址
数组元素的表示方法,下标法 和 指针法, 即若 p=q,
则 p[i] ? q[i] ? *(p+i) ? *(q+i)
形参数组 实质上是 指针变量,即 int q[ ] ? int *q
在定义指针变量（不是形参）时,不能把 int *p 写成 int p[];
系统只给 p分配能保存一个指针值的内存区 (一般 2字节
）；而给 q分配 2*10字节的内存区
9.3.4 一级指针变量与一维数组的关系 (小节 )
9.3.5.1 对于一维数组 (复习总结 )
（ 1）数组名 array表示数组的首地址，即 array[0]的
地址；
（ 2）数组名 array是地址 常量
（ 3） array+i是元素 array[i]的地址
（ 4） array[i] ? *(array+i)
array int array[10];
9.3.5 指针与二维数组
对于二维数组：
（ 1） a是数组名，
包含三个元素
a[0],a[1],a[2]
（ 2）每个元素 a[i]
又是一个一维
数组，包含 4个
元素
a
a+1
a+2
*(*(a+0)+1)
*(a[0]+1)int a[3][4];
a[0]
a[1]
a[2]
2000
2008
2016
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]+1
a[1]+1
a[2]+1
*(a+0)+1
*(a+1)+1
*(a+2)+1
9.3.5.2 二维数组, 行指针与列指针（ 1）
– 对二维数组 int a[3][4],有
?a-----二维数组的首地址，即第 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列元素地址，指向列
int a[3][4];
a[0]
a[1]
a[2]
2000
2008
2016
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
a+1
a+2
9.3.5.2 行指针与列指针（ 2）
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]
二维数组元素表示形式：
（ 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+2
9.3.5.2 行指针与列指针（ 3）
表示形式 含义 地址
a 二维数组名，数组首地址
a[0],*(a+0),*a 第 0行第 0列元素地址
a+1 第 1行首地址
a[1],*(a+1) 第 1行第 0列元素地址
a[1]+2,*(a+1)+2,&a[1][2] 第 1行第 2列元素地址
*(a[1]+2),*(*(a+1)+2),a[1][2] 第 1行第 2列元素值
2000
2000
2008
2008
2012
13
表格说明
– 指向二维数组 元素 的指针变量
例 指向二维数组元素的指针变量
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=*a;
p=&a[0][0];
p=*(a+0);
p=a;
p=*a;
p=&a[0][0];
p=(int *)a;
p=a;
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
9.3.5.3 二维数组的指针变量
?定义形式,数据类型 (*指针名 )[一维数组长度 ];
例 int (*p)[4];
( )不能少
int (*p)[4]与 int *p[4]不同
p的值是一维数组的
首地址,p是 行指针
可让 p指向二维数组某一行
如 int a[3][4],(*p)[4]=a;
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[0]+1或 *p+1
p[1]+2或 *(p+1)+2
*(*p+1)或 (*p)[1]
*(*(p+1)+2)
一维数组指针变量数组长度和
二维数组 列数 必须相同
─指向一维数组的指针变量 (行指针 )
main()
{ int a[3][4]={{1,2,3,4},{3,4,5,6},{5,6,7,8}};
int i;
int (*p)[4]=a,*q=a[0];
for(i=0;i<3;i++)
{ if(i==0)
(*p)[i+i/2]=*q+1;
else
p++,++q;
}
for(i=0;i<3;i++)
printf("%d,",a[i][i]);
printf("%d,%d\n",*((int *)p),*q);
}
运行结果,2,4,7,5,3
1 2 3 4
3 4 5 6
5 6 7 8
p
q
2p
q
p
q
例 二维数组与指针运算
– 用指向变量的指针变量
– 用指向一维数组的指针变量
– 用二维数组名
实参 形参
数组名 int x[][4]
指针变量 int (*q)[4]
数组名 int x[][4]
指针变量 int (*q)[4]
数组名 a
数组名 a
指针变量 p1
指针变量 p1
若 int a[3][4]; int (*p1)[4]=a; int *p2=a[0];
指针变量 p2 指针变量 int *q
9.3.5.4 二维数组的指针作函数参数
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);
}
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));
}
列指针
行指针
函数说明
float p[][4]
65 52 79 60
80 87 90 81
90 99 100 98
p
p
? p[n][i]
例 3个学生各学 4门课，计算总平均分，并输出第 n个学生成绩
9.4 指针与字符串
– 字符串表示形式
? 用字符数组实现
例 main( )
{ char string[]=“I love China!”;
printf(“%s\n”,string);
printf(“%s\n”,string+7);
}
I
l
o
v
e
C
h
i
string[0]
string[1]
string[2]
string[3]
string[4]
string[5]
string[6]
string[7]
string[8]
string[9]
string
string[10]
string[11]
string[12]
string[13]
n
!
a
\0
例 main( )
{ char *string=“I love China!”;
printf(“%s\n”,string);
string+=7;
while(*string)
{ putchar(string[0]);
string++;
}
}
I
l
o
v
e
C
h
i
string
n
!
a
\0
字符指针 初始化,把字符串 首地址 赋给 string
? char *string;
string=“I love China!”;
string
*string!=0
用字符指针实现
例 用函数调用实现字符串复制
（ 1）用字符数组作参数
（ 2）用字符指针变量作参数
a
I
a
m
a
t
e
a
c
e
h
\0
r
.
from
a b
y
u
a
r
a
s
u
t
n
d
e
to
b
o
e
t
.
\0
I
a
a
e
c
e
h
\0
r
.
t
.
\0
m
t
a
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);
}
字符串指针作函数参数
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
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}; (?)
scanf(“%s”,str);
printf(“%s”,str);
gets(str);
puts(str);
字符串与数组关系
9.5.1函数指针：函数在编译时被分配的入口地址,用
函数名表示
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()不同
9.5 指针与函数
例 用函数指针变量作参数，求最大值、最小值和两数之和
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);
}
9.5.2 用函数指针变量作函数参数
?函数定义形式：
类型标识符 *函数名 (参数表 );
例 int *f(int x,int y)
例 指针函数实现：有若干学生成绩，要求输入学生序号后，
能输出其全部成绩
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);
}
pointer
pointer+1
34 78 90 66
56 89 67 88
60 70 80 90
score数组
p p p p
9.5.3 返回指针值的函数
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
2
3
指针变量 y
指针变量 x(f1)
2002
2000
COPY
变量 a
变量 b
(main)
指针变量 p**
例 写一个函数，求两个 int型变量中居于较大值的变量的地址（ 1）
…...
…...
2000
2008
200A
2002
2004
2006
2 变量 a变量 b
(main)
3 指针变量 p
**2002
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);
}
例 写一个函数，求两个 int型变量中居于较大值的变量的地址（ 2）
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
3
变量 y
变量 x(f3)
3
2
COPY
变量 a
变量 b
(main)
指针变量 p**
例 写一个函数，求两个 int型变量中居于较大值的变量的地址（ 3）
不能返回 形参 或 局部变量
的 地址 作函数返回值
…...
…...
2000
2008
200A
2002
2004
2006
2 变量 a变量 b
(main)
3 指针变量 p
**200A
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);
}
例 写一个函数，求两个 int型变量中居于较大值的变量的地址（ 4）
用于处理二维数组或多个字符串
– 指针数组
? 定义：数组中的元素为指针变量
? 定义形式,[存储类型 ] 数据类型 *数组名 [数组长度说明 ]；
例 int *p[4];
指针所指向变量的数据类型指针本身的存储类型区分 int *p[4]与 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
2
4
6
初始化,
main()
{ int b[2][3],*pb[ ]={b[0],b[1]};
……..
}
int *pb[2]
pb[0]
pb[1]
int b[2][3]
1
2
3
2
4
6
9.6 指针数组和多级指针
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] 0
赋值,
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;
……..
}
或,
main()
{ char *p[4];
p[0]= "Fortran";
p[1]= "Lisp";
p[2]= "Basic";
p[3]=NULL;
……..
}
初始化,
main()
{ char *p[]={"Fortran","Lisp","Basic",NULL};
……..
}
i s \
F r t r a \
a s i c \
[0]
[1]
[2]
[3]
指针数组赋值与初始化
char name[5][9]={“gain”,“much”,“stronger”,“point”,“bye”};
char *name[5]={“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
name[0]
name[1]
name[2]
name[3]
name[4] 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
b y e \0
二维数组存储空间固定
字符指针数组相当于 可变列长 的二维数组
指针数组元素的作用相当于二维数组的行名
但指针数组中元素是指针变量
二维数组的行名是 地址常量
二维数组与指针数组区别,
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(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]
int b[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)
1
2
3
2
4
6
例 用指针数组处理二维数组
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
jk
j
j
j
i=0
例 对字符串排序（简单选择排序）图解 1
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
BASICk
k
j
j
j
i=1
k
例 对字符串排序（简单选择排序）图解 2
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
BASICk
k j
j
i=2
例 对字符串排序（简单选择排序）图解 3
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
i=3
例 对字符串排序（简单选择排序）图解 4
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
例 对字符串排序（简单选择排序）图解 5
? 定义, 指向指针的指针
? 一级指针,指针变量中存放目标变量的地址
p1
&p2 &i 3
P2(指针变量 ) i(整型变量 )例 int **p1;
int *p2;
int i=3;
p2=&i;
p1=&p2;
**p1=5;
二级指针,指针变量中存放一级指针变量的地址
例 int *p;
int i=3;
p=&i;
*p=5;
&i 3
P(指针变量 ) i(整型变量 )
一级指针 单级间接寻址
二级指针 一级指针 目标变量
二级间接寻址
多级指针
定义形式,[存储类型 ] 数据类型 **指针名；
如 char **p;
例 int i,**p;
p=&i; (?)//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 ***p;
四级指针 char ****p;
多级指针定义形式
2000
2008
200A
2002
2004
2006
1
2
变量 a
变量 b
(main)
指针变量 p2000
指针变量 q2002
#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);
}
2002
2000
COPY
指针变量 s
指针变量 r(swap)
指针变量 t2000
2002
2000
例 一级指针与二级指针图解 1
2000
2008
200A
2002
2004
2006
1
2
变量 a
变量 b
(main)
指针变量 p2000
指针变量 q2002
#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);
} 输出, 1,2
例 一级指针与二级指针图解 2
#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
a
b
p
q
r
s
a
b
p
q
s
r
a
b
p
q
输出, 1,2
例 一级指针与二级指针图解 3
用一级指针
达不到要求 !
#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)
指针变量 p2000
指针变量 q2002
2006
2004
COPY
二级指针 s
二级指针 r(swap)
指针变量 t
2000
2002
2000
例 一级指针与二级指针图解 4
#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)
指针变量 p2000
指针变量 q200220002002
输出, 2,1
例 一级指针与二级指针图解 5
#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
b
a
p
q
a
b
r
s
p
q
a
b
r
s
p
q
输出, 2,1
例 一级指针与二级指针图解 6
? 命令行：在操作系统状态下，为执行某个程序而键入
的一行字符
? 命令行一般形式,命令名 参数 1 参数 2……… 参数 n
main(int argc,char *argv[])
{ ………
}
命令行参数传递
带参数的 main函数形式：
C:\TC> copy[.exe] source.c temp.c
有 3个字符串参数的命令行
命令行中参数个数 元素指向命令行参数
中各字符串首地址
形参名任意
命令行 实参 main(形参 )
系统自动调用
main函数时传递
第一个参数, main所在的 可执行文件名
9.7 命令行参数
定义 含义
int i;
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为指针变量，它指向一个指向整型数据的指针变量
指针的数据类型
