Download presentation
Presentation is loading. Please wait.
1
9.1 地址、指针和变量 9.2 指针运算 9.3 指针与数组 9.4 函数与指针 9.5 程序综合举例 9.6 上机实训
2
【本章要点】 本章主要介绍指针的基本概概念，指针运算，指针与数组，指针与函数等内容。指针是C语言的一个重要概念，也是C语言的一个重要特色。正确灵活的运用指针，可以使程序简洁、紧凑、高效；可以有效地表示复杂的数据结构。可以说，不掌握指针就没有掌握C语言的精华。
3
9.1 地址、指针和变量 地址：内存单元的编号也叫做地址。 指针：内存单元地址称为指针，即指针就是地址。
9.1 地址、指针和变量 地址：内存单元的编号也叫做地址。 指针：内存单元地址称为指针，即指针就是地址。 指针变量：存放指针的变量称为指针变量。 各种类型变量都有地址，通过地址（指针）或变量名访问变量。
4
9.1.1地址和指针的基本概念 变量：命名的内存空间，用于存放各种类型的数据。 变量名：变量名是给内存空间取的一个容易记忆的名字。 变量的地址：变量所使用的内存空间的地址。 变量值：在变量单元中存放的数值。即变量的内容。 “&”符号为取地址符号，可以取得变量的地址。
5
例如：输出整形变量a,b,c在内存分配的地址。
void main() { int a,b,c; printf(“\n%ld ,%ld ,%ld”,&a,&b,&c); } 运行结果为: ， ，
6
直接访问：在程序中使用变量名（变量地址）存取变量值的方式，称为“直接访问”方式。以前的程序中都是采用这种方式。
间接访问：定义一个指针变量来存放了一个变量的地址，通过指针变量存取变量的值，称为“间接访问”方式。 如图9.2所示：指针变量P存放变量a变量的地址393176，a变量的值为5。
7
9.1.2 指针变量类型的定义 定义的一般格式为： <存储类型> <数据类型> <*指针变量名>[=初始地址值]； 其中： （1）存储类型是任选项，主要有 auto型、register型、static型和extern型四种。 （2）数据类型是指针变量所指向变量数据类型。可以是int、char、float等基本类型，也可是数组等构造类型。 例如： int *p1,*p2;
![9.1.2 指针变量类型的定义 定义的一般格式为： <存储类型> <数据类型> <*指针变量名>[=初始地址值]； 其中： （1）存储类型是任选项，主要有 auto型、register型、static型和extern型四种。](http://slidesplayer.com/slide/16239889/95/images/7/9.1.2+%E6%8C%87%E9%92%88%E5%8F%98%E9%87%8F%E7%B1%BB%E5%9E%8B%E7%9A%84%E5%AE%9A%E4%B9%89+%E5%AE%9A%E4%B9%89%E7%9A%84%E4%B8%80%E8%88%AC%E6%A0%BC%E5%BC%8F%E4%B8%BA%EF%BC%9A+%3C%E5%AD%98%E5%82%A8%E7%B1%BB%E5%9E%8B%3E+%3C%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%3E+%3C%2A%E6%8C%87%E9%92%88%E5%8F%98%E9%87%8F%E5%90%8D%3E%5B%3D%E5%88%9D%E5%A7%8B%E5%9C%B0%E5%9D%80%E5%80%BC%5D%EF%BC%9B+%E5%85%B6%E4%B8%AD%EF%BC%9A+%EF%BC%881%EF%BC%89%E5%AD%98%E5%82%A8%E7%B1%BB%E5%9E%8B%E6%98%AF%E4%BB%BB%E9%80%89%E9%A1%B9%EF%BC%8C%E4%B8%BB%E8%A6%81%E6%9C%89+auto%E5%9E%8B%E3%80%81register%E5%9E%8B%E3%80%81static%E5%9E%8B%E5%92%8Cextern%E5%9E%8B%E5%9B%9B%E7%A7%8D%E3%80%82.jpg "（2）数据类型是指针变量所指向变量数据类型。可以是int、char、float等基本类型，也可是数组等构造类型。 例如： int *p1,*p2;")
8
9.1.3 指针变量的赋值 指针变量一定要周赋值后才可以使用。禁止使用未初始化或未赋值的指针(否则可能导致系统的崩溃)。 指针运算符：
(1) &: 取地址运算符。 功能：取变量的地址。单目运算符，结合性为自右向左。 例如：&a为取变量a的地址。 (2) *: 取内容运算符 它的作用：与&相反，表示指针所指向的变量（取变量内容）。*是单目运算符，其结合性为自右向左。 例如：*p为指针变量p所指向的变量。
9
指针变量的赋值方法： 1．将地址直接赋值给指针变量 例如：float *f=(float *)malloc(4); 注： malloc()函数申请动态分配内存空间，返回空间首地址； free()函数释放不用内存空间。 使用这2个函数时需要声明头文件<stdlib.h>或<alloc.h>。 2.将变量的地址赋值给指针变量 例如： int i,*p; p=&i;
10
【例9.1】 通过指针变量访问整形变量。 void main() { int a,b; int *p1,*p2; /*定义两个指针变量*/ a=100;b=50; p1=&a; p2=&b; /* p1指向a，p2指向b*/ printf(“%d,%d\n”,a,b); printf(“%d,%d＼n”,*p1,*p2); } 运行结果： 100,50
11
【例9.2】 输入两个整数，按先大后小的顺序输出。
【例9.2】 输入两个整数，按先大后小的顺序输出。 程序如下： void main() { int a,b,*p1,*p2,*p; scanf(“%d%d”,&a,&b); p1=&a;p2=&b; if (a<b) {p=p1;p1=p2;p2=p;} printf(“\na=%d,b=%d\n”,a,b); printf(“max=%d,min=%d\n”,*p1,*p2); } 运行结果为： 输入：5 9 ↙ 输出：a=5,b=9 max=9,min=5 程序运行中，指针变量p1,p2的指向变化如图
12
9.2 指针运算 9.2.1指针运算符 1．取地址运算符 & 功能：取变量的地址。单目运算符，结合性为自右向左。
例如：&a为取变量a的地址。 2．取内容运算符 * 功能：与&相反，表示指针所指向的变量（取指针内容，即变量）。*是单目运算符，其结合性为自右向左。在*运算符之后跟的变量必须是指针变量。
13
9.2.2指针变量的运算 1．赋值运算 有以下几种形式： (1) 指针变量初始化赋值 例如：
float *f=(float *)malloc(4); int i,*p=&i; (2) 变量的地址赋予指针变量 int a,*p; p=&a; /*把整型变量a的地址赋予整型指针变量p*/ (3) 指针变量的值赋予另一个指针变量（类型相同） int a,*pa=&a,*pb; pb=pa; /*把a的地址赋予指针变量pb*/
14
或写为：p=&a[0]; 或：int a[5],*p=a; (5) 字符串首地址赋予指针变量。 例如：char *pc;
(4) 数组的首地址赋予指针变量。 例如：int a[5],*p; p=a; 或写为：p=&a[0]; 或：int a[5],*p=a; (5) 字符串首地址赋予指针变量。 例如：char *pc; pc="Hello"; 或写为： char *pc="Hello"; 说明：并不是把整个字符串装入指针变量，而是把存放该字符串的首地址装入指针变量。 (6) 函数的入口地址赋予指针变量。 例如： int (*pf)(); pf=f; /*f为函数名*/
![或写为：p=&a[0]; 或：int a[5],*p=a; (5) 字符串首地址赋予指针变量。 例如：char *pc;](http://slidesplayer.com/slide/16239889/95/images/14/%E6%88%96%E5%86%99%E4%B8%BA%EF%BC%9Ap%3D%26a%5B0%5D%3B+%E6%88%96%EF%BC%9Aint+a%5B5%5D%2C%2Ap%3Da%3B+%285%29+%E5%AD%97%E7%AC%A6%E4%B8%B2%E9%A6%96%E5%9C%B0%E5%9D%80%E8%B5%8B%E4%BA%88%E6%8C%87%E9%92%88%E5%8F%98%E9%87%8F%E3%80%82+%E4%BE%8B%E5%A6%82%EF%BC%9Achar+%2Apc%3B.jpg "(4) 数组的首地址赋予指针变量。 例如：int a[5],*p; p=a; 或写为：p=&a[0]; 或：int a[5],*p=a; (5) 字符串首地址赋予指针变量。 例如：char *pc; pc= Hello ; 或写为： char *pc= Hello ; 说明：并不是把整个字符串装入指针变量，而是把存放该字符串的首地址装入指针变量。 (6) 函数的入口地址赋予指针变量。 例如： int (*pf)(); pf=f; /*f为函数名*/")
15
2.加减运算 (1)指针加减任意整数运算 运算条件：必须是指向数组的指针变量（即数组指针，在9.3.1节中介绍），才能加可以加上或减去一个整数n。对指向其它类型变量的指针变量作加减运算是毫无意义的。 运算形式：设有数组指针变量p，则有: p+n,p-n,p++,++p,p--,--p 运算都是合法的。 运算作用：指针变量±n就是把指针指向的当前位置向前（减）或向后(加)移动n个元素位置。 注意：数组指针变量±n不是地址加减n，而是移动n个元素位置。 例如： int a[5],*p; p=a; /*p指向数组a，也是指向a[0]*/ p=p+2; /*p指向a[2]，即p的值为&p[2]*/
16
(2)两指针变量相减 运算条件：必须是指向同一数组的2个指针变量才能进行两指针相减运算。 运算形式：设有数组指针变量p、q，则有: p-q 运算作用：相减所得之差是两个指针所指数组元素之间相差的元素个数。 例如: 设pf1=2010H，pf2=2000H且指向同一实型数组a的两个指针变量， 则得： pf1-pf2=(2000H-2010H)/4=4 注意： pf1+pf2是什么意思呢? 毫无实际意义。
17
(3)指针的关系运算 运算条件：必须是指向同一数组的2个指针变量才能进行关系运算。 运算作用：两个指针变量通过关系运算进行比较，主要用于判断他们的前后位置关系。 例如：设如果pa和qa都指向同一个数组a， 则有：pa>qa、pa<qa、 pa>=qa、 pa<=qa、 pa==qa、 pa!=qa 说明：当pa所指元素在qa之前，则表达式“pa<qa”为真（值为1）； 当pa和qa都指向同一个元素时，表达式“pa==qa” 为真（值为1）。
18
【例9.4】(1)已知指针p的指向如图9.5所示，执行语句*p++；后，*p的值是多少?p指向哪一个元素？
解答： 先进行*p的操作，得到p所指变量的值20，然后进行p+1操作,指向a[2]。 先将指针p加一，指向a[2],然后进行*p操作，值是30。 ++*p是使p所指的变量的内容加一，值为21，p仍指向a[1]。
19
9.3 指针与数组 9.3.1 数组指针 1.指向一维数组的指针 数组名代表数组的首地址，是一个常量。
数组指针：就是指向数组元素地址的指针变量。 引用数组元素除了用下标法外也可以用指针法来引用数组元素。 例如：int a[8]={2,4,6,8,10,12,14,16}; int *p;p=&a[0]; 如图9.6所示： 下面的语句是等价的： p=&a[0]； p=a;
20
例如： int a[8]={2,4,6,8,10,12,14,16}; int *p=&a[0]; 它相当于： int *p; p=&a[0]; 有以下四种方法引用数组元素a[k]: *(p+k)、*(a+k)、p[k]、a[k] 前两种称为指针法，后两种称为下标法。 注意：p++; 操作时允许的。 a++; 操作是错误的，因为a是常量。
![例如： int a[8]={2,4,6,8,10,12,14,16}; int *p=&a[0]; 它相当于： int *p; p=&a[0]; 有以下四种方法引用数组元素a[k]: *(p+k)、*(a+k)、p[k]、a[k]](http://slidesplayer.com/slide/16239889/95/images/20/%E4%BE%8B%E5%A6%82%EF%BC%9A+int+a%5B8%5D%3D%7B2%2C4%2C6%2C8%2C10%2C12%2C14%2C16%7D%3B+int+%2Ap%3D%26a%5B0%5D%3B+%E5%AE%83%E7%9B%B8%E5%BD%93%E4%BA%8E%EF%BC%9A+int+%2Ap%3B+p%3D%26a%5B0%5D%3B+%E6%9C%89%E4%BB%A5%E4%B8%8B%E5%9B%9B%E7%A7%8D%E6%96%B9%E6%B3%95%E5%BC%95%E7%94%A8%E6%95%B0%E7%BB%84%E5%85%83%E7%B4%A0a%5Bk%5D%3A+%2A%28p%2Bk%29%E3%80%81%2A%28a%2Bk%29%E3%80%81p%5Bk%5D%E3%80%81a%5Bk%5D.jpg "前两种称为指针法，后两种称为下标法。 注意：p++; 操作时允许的。 a++; 操作是错误的，因为a是常量。")
21
① 执行p++ ,p指向下一个元素，即a[1]。*p为a[1]的值。 ② *p++,相当于 *(p++）。
注意指针变量的运算。 设指针p=a（a为数组名） ① 执行p++ ,p指向下一个元素，即a[1]。*p为a[1]的值。 ② *p++,相当于 *(p++）。 ③ *(p++)与 *(++p)作用不同。 ④ (*p)++，表示将p所指向的元素值加1. ⑤ 如果p当前指向a数组中的第i个元素，则： *(p--)相当于a[i--]，先取p值作“*”运算，再使p自减。 *(++p)相当于a[++i]，先使p自加，再作*运算。 *(--p)相当于a[--i], 先使p自减，再作*运算。
![① 执行p++ ,p指向下一个元素，即a[1]。*p为a[1]的值。 ② *p++,相当于 *(p++）。](http://slidesplayer.com/slide/16239889/95/images/21/%E2%91%A0+%E6%89%A7%E8%A1%8Cp%2B%2B+%2Cp%E6%8C%87%E5%90%91%E4%B8%8B%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%EF%BC%8C%E5%8D%B3a%5B1%5D%E3%80%82%2Ap%E4%B8%BAa%5B1%5D%E7%9A%84%E5%80%BC%E3%80%82+%E2%91%A1+%2Ap%2B%2B%2C%E7%9B%B8%E5%BD%93%E4%BA%8E+%2A%28p%2B%2B%EF%BC%89%E3%80%82.jpg "注意指针变量的运算。 设指针p=a（a为数组名） ① 执行p++ ,p指向下一个元素，即a[1]。*p为a[1]的值。 ② *p++,相当于 *(p++）。 ③ *(p++)与 *(++p)作用不同。 ④ (*p)++，表示将p所指向的元素值加1. ⑤ 如果p当前指向a数组中的第i个元素，则： *(p--)相当于a[i--]，先取p值作 * 运算，再使p自减。 *(++p)相当于a[++i]，先使p自加，再作*运算。 *(--p)相当于a[--i], 先使p自减，再作*运算。")
22
【例9.5】用上面介绍的四种不同方法访问数组元素。
#include<stdio.h> void main() { int a[5]={0,1,2,3,4}; int *p,i; for(i=0;i<5;i++) { printf(“%d ”,a[i]); printf(“%d ”,*(a+i)); printf(“%d ”,p[i]); printf(“%d ”,*(p+i)); printf(“\n”); } 程序中的四个输出是一样的。程序输出如下：
23
【例9.6】通过指针变量输入输出a数组的8个元素。程序如下：
void main() { int *p,i,a[8]; p=a; for (i=0;i<8;i++) scanf(“%d”,p++); printf（”＼n”）; p=a; /*注意此语句的作用*/ for (i=0;i<8;i++,p++) printf(“%4d”,*p); }
24
二维数组a，可视为三个一维数组：a[0]、a[1]、a[2]；而每个一维数组又是一维数组，分别由4个元素组成，即： 二维数组名 一维数组名
2.指向二维数组的指针 设有一个二维数组a定义为： int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; 二维数组a，可视为三个一维数组：a[0]、a[1]、a[2]；而每个一维数组又是一维数组，分别由4个元素组成，即： 二维数组名 一维数组名 数组元素 a a[0] a[1] a[2] 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，可视为三个一维数组：a[0]、a[1]、a[2]；而每个一维数组又是一维数组，分别由4个元素组成，即： 二维数组名 一维数组名](http://slidesplayer.com/slide/16239889/95/images/24/%E4%BA%8C%E7%BB%B4%E6%95%B0%E7%BB%84a%EF%BC%8C%E5%8F%AF%E8%A7%86%E4%B8%BA%E4%B8%89%E4%B8%AA%E4%B8%80%E7%BB%B4%E6%95%B0%E7%BB%84%EF%BC%9Aa%5B0%5D%E3%80%81a%5B1%5D%E3%80%81a%5B2%5D%EF%BC%9B%E8%80%8C%E6%AF%8F%E4%B8%AA%E4%B8%80%E7%BB%B4%E6%95%B0%E7%BB%84%E5%8F%88%E6%98%AF%E4%B8%80%E7%BB%B4%E6%95%B0%E7%BB%84%EF%BC%8C%E5%88%86%E5%88%AB%E7%94%B14%E4%B8%AA%E5%85%83%E7%B4%A0%E7%BB%84%E6%88%90%EF%BC%8C%E5%8D%B3%EF%BC%9A+%E4%BA%8C%E7%BB%B4%E6%95%B0%E7%BB%84%E5%90%8D+%E4%B8%80%E7%BB%B4%E6%95%B0%E7%BB%84%E5%90%8D.jpg "2.指向二维数组的指针. 设有一个二维数组a定义为： int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; 二维数组a，可视为三个一维数组：a[0]、a[1]、a[2]；而每个一维数组又是一维数组，分别由4个元素组成，即： 二维数组名. 一维数组名. 数组元素. a. a[0] a[1] a[2] 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]")
25
用数组名表示二维数组的行地址 数组名总是代表数组的首地址。 则有：a 为二维整型数组名,a=2000。 a 就是第0行的首地址2000。即为a[0] a+1 代表第一行首地址。为2008。即为a[1] a+2 代表第二行首地址。即2016。即为a[2] (2)用数组名表示二维数组元素地址 二维数组中a[0]、a[1]、a[2]都是地址， 则有：*(a+0)、*(a+1)和*(a+2)也是地址，它们分别是第0行、1行和2行的第0列首地址。 因此，a[0]+1等介于*(a+0)+1，即&a[0][1]。 a[1]+2等介于*(a+1)+2，即&a[1][2]。 a[2]+3等介于*(a+1)+3，即&a[1][3]。
![用数组名表示二维数组的行地址 数组名总是代表数组的首地址。 则有：a 为二维整型数组名,a=2000。 a 就是第0行的首地址2000。即为a[0] a+1 代表第一行首地址。为2008。即为a[1]](http://slidesplayer.com/slide/16239889/95/images/25/%E7%94%A8%E6%95%B0%E7%BB%84%E5%90%8D%E8%A1%A8%E7%A4%BA%E4%BA%8C%E7%BB%B4%E6%95%B0%E7%BB%84%E7%9A%84%E8%A1%8C%E5%9C%B0%E5%9D%80+%E6%95%B0%E7%BB%84%E5%90%8D%E6%80%BB%E6%98%AF%E4%BB%A3%E8%A1%A8%E6%95%B0%E7%BB%84%E7%9A%84%E9%A6%96%E5%9C%B0%E5%9D%80%E3%80%82+%E5%88%99%E6%9C%89%EF%BC%9Aa+%E4%B8%BA%E4%BA%8C%E7%BB%B4%E6%95%B4%E5%9E%8B%E6%95%B0%E7%BB%84%E5%90%8D%2Ca%3D2000%E3%80%82+a+%E5%B0%B1%E6%98%AF%E7%AC%AC0%E8%A1%8C%E7%9A%84%E9%A6%96%E5%9C%B0%E5%9D%802000%E3%80%82%E5%8D%B3%E4%B8%BAa%5B0%5D+a%2B1+%E4%BB%A3%E8%A1%A8%E7%AC%AC%E4%B8%80%E8%A1%8C%E9%A6%96%E5%9C%B0%E5%9D%80%E3%80%82%E4%B8%BA2008%E3%80%82%E5%8D%B3%E4%B8%BAa%5B1%5D.jpg "a+2 代表第二行首地址。即2016。即为a[2] (2)用数组名表示二维数组元素地址. 二维数组中a[0]、a[1]、a[2]都是地址， 则有：*(a+0)、*(a+1)和*(a+2)也是地址，它们分别是第0行、1行和2行的第0列首地址。 因此，a[0]+1等介于*(a+0)+1，即&a[0][1]。 a[1]+2等介于*(a+1)+2，即&a[1][2]。 a[2]+3等介于*(a+1)+3，即&a[1][3]。")
26
a[0][1]的值 可表示为：*(a[0]+1)和*(*(a+0)+1)
a[i][j]的值 可表示应为：*(a[i]+j)和*(*(a+i)+j)。 数组元素三种形式引用： ⑴ a[i][j] 下标法 ⑵ *(a[i]+j) 用一维数组名 ⑶ *(*(a+i)+j) 用二维数组名
![a[0][1]的值 可表示为：*(a[0]+1)和*(*(a+0)+1)](http://slidesplayer.com/slide/16239889/95/images/26/a%5B0%5D%5B1%5D%E7%9A%84%E5%80%BC+%E5%8F%AF%E8%A1%A8%E7%A4%BA%E4%B8%BA%EF%BC%9A%2A%28a%5B0%5D%2B1%29%E5%92%8C%2A%28%2A%28a%2B0%29%2B1%29.jpg "a[i][j]的值 可表示应为：*(a[i]+j)和*(*(a+i)+j)。 数组元素三种形式引用： ⑴ a[i][j] 下标法. ⑵ *(a[i]+j) 用一维数组名. ⑶ *(*(a+i)+j) 用二维数组名.")
27
3.用指针变量指向二维数组及其元素 (1) 指向数组元素的指针变量
二维数组的每个元素在内存中存储在地址连续的存储空间中。如图9.7和9.8所示。用指向数组元素的指针变量来引用数组。
28
【例9.7】 用指针变量输出二维数组每个元素的值。
void main() { int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; int *p; for (p=a[0];p<a[0]+12;p++) printf(“%4d”,*p); } 注意：for语句中的p=a[0]可改为p=&a[0][0],但不能为p=a。
29
【例9.8】 输出二维数组a中任一行任一列元素的值。
程序如下： void main() { int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; int *p＝a[0],i,j; scanf(“%d,%d”,&i,&j); printf(“\n%4d”,*(p+i*4+j)); } 运行程序输入：2,2↙ 输出：
30
(2) 指向由m个整数组成的一维数组的指针变量
定义格式： (*标识符)[一维数组元素个数]; 例如：int (*q)[4]； 定义一个指针变量q,它指向包含有4个元素的一维数组。 注意：*q必须放在括弧内，否则就变成了定义指针数组。 由于q是指向有4个整形元素的一维数组的指针变量，因此，q+1是将地址值加上4*2，即指向下一个一维数组。如图9-8所示。
31
设有如下定义： int a[3][4]= {{1,2,3,4},{5,6,7,8},{9,10,11,12}}; int (*q)[4]; q=a; 则： q+0 为二维数组第0行首地址，与a+0或*(a+0)相同； q+1 为二维数组第1行首地址，与a+1或*(a+1)相同； q+2 为二维数组第2行首地址，与a+2或*(a+2)相同； *(q+i)+j 为第i行第j列元素的地址，与*(a+i)+j相同； *(*(q+i)+j) 为第i行第j列元素，与*(*(a+i)+j)相同,即a[i][j]。
![设有如下定义： int a[3][4]= {{1,2,3,4},{5,6,7,8},{9,10,11,12}}; int (*q)[4]; q=a; 则： q+0 为二维数组第0行首地址，与a+0或*(a+0)相同；](http://slidesplayer.com/slide/16239889/95/images/31/%E8%AE%BE%E6%9C%89%E5%A6%82%E4%B8%8B%E5%AE%9A%E4%B9%89%EF%BC%9A+int+a%5B3%5D%5B4%5D%3D+%7B%7B1%2C2%2C3%2C4%7D%2C%7B5%2C6%2C7%2C8%7D%2C%7B9%2C10%2C11%2C12%7D%7D%3B+int+%28%2Aq%29%5B4%5D%3B+q%3Da%3B+%E5%88%99%EF%BC%9A+q%2B0+%E4%B8%BA%E4%BA%8C%E7%BB%B4%E6%95%B0%E7%BB%84%E7%AC%AC0%E8%A1%8C%E9%A6%96%E5%9C%B0%E5%9D%80%EF%BC%8C%E4%B8%8Ea%2B0%E6%88%96%2A%28a%2B0%29%E7%9B%B8%E5%90%8C%EF%BC%9B.jpg "q+1 为二维数组第1行首地址，与a+1或*(a+1)相同； q+2 为二维数组第2行首地址，与a+2或*(a+2)相同； *(q+i)+j 为第i行第j列元素的地址，与*(a+i)+j相同； *(*(q+i)+j) 为第i行第j列元素，与*(*(a+i)+j)相同,即a[i][j]。")
32
【例9.9】 用指向有m个元素一维数组的指针变量输出二维数组任一行任一列元素的值。
void main() { int a[3][4]= {{1,2,3,4},{5,6,7,8},{9,10,11,12}}; int (*q)[4]; /*指针变量p是指向有4个元素的一维数组*/ q=a; scanf(“%d,%d”,&i,&j); printf(“\na[%d][%d]=%d”,i,j,*(*(q+i)+j)); } 运行结果如下： 输入：1,2↙ 输出：a[1][2]=13
33
【例9.10】有一个3×3的矩阵a。编程对它进行转置操作。
程序思想：主对线为界，对矩阵元素的行列元纯洁互换即可。即a[i][j]与为a[j][i]交换。 程序结构分为以下几块： (1)对数组a进行初始化； (2)给数组a的指针p赋值； (3)进行数组元素的转置； (4)输出结果数组。
34
#include<stdio.h>
void main() { int a[3][3]={1,2,3,4,5,6,7,8,9}; int i,j,k，(*p)[3]=a; for(i=0;i<3;i++) { for(j=i;j<3;j++) { k=*(*(p+i)+j); *(*(p+i)+j)= *(*(p+j)+i); *(*(p+j)+i)=k; } { printf(“\n”); for(j=0;j<3;j++) printf(“%d ”, *(*(p+i)+j)); 输出结果为：
35
函数的参数传递可以采用地址传递。所以指针可作为函数参数。
4.指针作为函数的参数 函数的参数传递可以采用地址传递。所以指针可作为函数参数。 当指针作为函数的形参时，实参传递的是地址，在函数中通过地址访问实参，所以，在函数中通过地址对实参的修改影响到实参的值。 【例9.11】输入的两个整数按大小顺序输出。 #include<stdio.h> void swap(int x,int y) { int temp; temp=x; x=y; y=temp; }
36
void main() { int a,b; scanf("%d,%d",&a,&b); if(a<b) swap(a,b);
printf("\n%d,%d\n",a,b); } 运行结果： 1, 2↙ 1，2 可见：此程序没能够达到题目要求。 虽然a<b，并且进入swap()函数进行数据交换，实现了x和y的交换，返回到主函数后，x和y都被释放掉了。
37
#include<stdio.h> swap(int *p1,int *p2) { int temp; temp=*p1;
【例9.12】输入的两个整数按大小顺序输出。 #include<stdio.h> swap(int *p1,int *p2) { int temp; temp=*p1; *p1=*p2; *p2=temp; } void main() { int a,b; int *p1,*p2; scanf("%d,%d",&a,&b); p1=&a;p2=&b; if(a<b) swap(p1,p2); printf("\n%d,%d\n",a,b); 运行结果： 1, 2↙ 2，1
38
5.数组名作为函数参数 【例9.13】 在主函数中定义数组，在被调用函数中用库函数产生20个100以内的随机整数，在主函数中输出这些整数。 程序如下： #include<stdio.h> #include “stdlib.h” #define N 20 getin(int x[ ],int m) { int i; for (i=0;i<m;i++) x[i]=random(100); /*产生100以内的随机整数*/ }
39
{ if (i%5==0 ) printf(“＼n”); printf(“%4d”,array[i]); }
void main() { int array[N]; int i; getin(array,N); for (i=0;i<N;i++) { if (i%5==0 ) printf(“＼n”); printf(“%4d”,array[i]); } 程序运行结果为： 数组指针作为函数参数可以分为4种情况： ☆ 形参、实参都是数组名； ☆ 实参是数组名，形参是指针变量； ☆ 形参、实参都是指针变量； ☆ 实参是指针变量，形参是数组名。
![{ if (i%5==0 ) printf( ＼n ); printf( %4d ,array[i]); }](http://slidesplayer.com/slide/16239889/95/images/39/%7B+if+%28i%255%3D%3D0+%29+printf%28+%EF%BC%BCn+%29%3B+printf%28+%254d+%2Carray%5Bi%5D%29%3B+%7D.jpg "void main() { int array[N]; int i; getin(array,N); for (i=0;i<N;i++) { if (i%5==0 ) printf( ＼n ); printf( %4d ,array[i]); } 程序运行结果为： 数组指针作为函数参数可以分为4种情况： ☆ 形参、实参都是数组名； ☆ 实参是数组名，形参是指针变量； ☆ 形参、实参都是指针变量； ☆ 实参是指针变量，形参是数组名。")
40
【例9.14】 用选择排序法,将10个数升序排列。 程序思想：选择排序的基本思想是，首先在10个数中选出一个最小数并将其存入a[0]；然后在剩下的9个数中再选出一个最小数并存入a[1]；依次类推，共选9次。 具体操作步骤： (1) 将10个数存入数组a。 (2) 在10个数选出一个最小数存入a[0]。 (3) 在剩下的9个数中，再选出一个最小数并存入a[1] (4) 在剩下的8个数中选出一个最小数并存入a[2]。 (5) 依此类推，直到选出第9个数，剩下的一个数是最大的。 (6) 用外循环控制选第几个最小数，内循环控制从第几个数开始选。
![【例9.14】 用选择排序法,将10个数升序排列。 程序思想：选择排序的基本思想是，首先在10个数中选出一个最小数并将其存入a[0]；然后在剩下的9个数中再选出一个最小数并存入a[1]；依次类推，共选9次。](http://slidesplayer.com/slide/16239889/95/images/40/%E3%80%90%E4%BE%8B9.14%E3%80%91+%E7%94%A8%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F%E6%B3%95%2C%E5%B0%8610%E4%B8%AA%E6%95%B0%E5%8D%87%E5%BA%8F%E6%8E%92%E5%88%97%E3%80%82+%E7%A8%8B%E5%BA%8F%E6%80%9D%E6%83%B3%EF%BC%9A%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F%E7%9A%84%E5%9F%BA%E6%9C%AC%E6%80%9D%E6%83%B3%E6%98%AF%EF%BC%8C%E9%A6%96%E5%85%88%E5%9C%A810%E4%B8%AA%E6%95%B0%E4%B8%AD%E9%80%89%E5%87%BA%E4%B8%80%E4%B8%AA%E6%9C%80%E5%B0%8F%E6%95%B0%E5%B9%B6%E5%B0%86%E5%85%B6%E5%AD%98%E5%85%A5a%5B0%5D%EF%BC%9B%E7%84%B6%E5%90%8E%E5%9C%A8%E5%89%A9%E4%B8%8B%E7%9A%849%E4%B8%AA%E6%95%B0%E4%B8%AD%E5%86%8D%E9%80%89%E5%87%BA%E4%B8%80%E4%B8%AA%E6%9C%80%E5%B0%8F%E6%95%B0%E5%B9%B6%E5%AD%98%E5%85%A5a%5B1%5D%EF%BC%9B%E4%BE%9D%E6%AC%A1%E7%B1%BB%E6%8E%A8%EF%BC%8C%E5%85%B1%E9%80%899%E6%AC%A1%E3%80%82.jpg "具体操作步骤： (1) 将10个数存入数组a。 (2) 在10个数选出一个最小数存入a[0]。 (3) 在剩下的9个数中，再选出一个最小数并存入a[1] (4) 在剩下的8个数中选出一个最小数并存入a[2]。 (5) 依此类推，直到选出第9个数，剩下的一个数是最大的。 (6) 用外循环控制选第几个最小数，内循环控制从第几个数开始选。")
41
程序如下： #include<stdio.h> void sort (int *x,int n) /*可以为：void sort(int x[],int n) */ { int i,j,k,t; for (i=0;i<n-1;i++) { k=i; /*变量k用来记录最小数的位置*/ for (j=i+1;j<n;j++) if (*(x+j)<*(x+k)) k=j; if (k!=i) {t=*(x+i);*(x+i)=*(x+k);*(x+k)=t;} } void main() int *p,i,a[10]; for (i=0;i<10;i++) scanf(“%d”,&a[i]); p=a; sort(p,10); for (p=a,i=0;i<10;i++,p++) printf(“%4d”,*p) 运行结果如下： ↙
![程序如下： #include<stdio.h> void sort (int *x,int n) /*可以为：void sort(int x[],int n) */ { int i,j,k,t;](http://slidesplayer.com/slide/16239889/95/images/41/%E7%A8%8B%E5%BA%8F%E5%A6%82%E4%B8%8B%EF%BC%9A+%23include%3Cstdio.h%3E+void+sort+%28int+%2Ax%2Cint+n%29+%2F%2A%E5%8F%AF%E4%BB%A5%E4%B8%BA%EF%BC%9Avoid+sort%28int+x%5B%5D%2Cint+n%29+%2A%2F+%7B+int+i%2Cj%2Ck%2Ct%3B.jpg "for (i=0;i<n-1;i++) { k=i; /*变量k用来记录最小数的位置*/ for (j=i+1;j<n;j++) if (*(x+j)<*(x+k)) k=j; if (k!=i) {t=*(x+i);*(x+i)=*(x+k);*(x+k)=t;} } void main() int *p,i,a[10]; for (i=0;i<10;i++) scanf( %d ,&a[i]); p=a; sort(p,10); for (p=a,i=0;i<10;i++,p++) printf( %4d ,*p) 运行结果如下： ↙")
42
9.3.2字符指针 1.字符串的表示形式 在C语言中，可以用两种方法实现对字符串的操作。 (1)用字符数组处理字符串。 【例9.15】
void main() { char str[]=“I love china!”; printf(“%s”,str); } 或： char str[]=”I love china!”; int i; for (i=0;*(str+i)!=’＼0’;i++) printf(“%c”,*(str+i)); 运行结果： I love china!
43
(2)用字符指针实现 将字符串的首地址赋给指针，用字符指针变量来处理字符串。 【例9.16】 用指针变量逐个输出数组中的每个字符。 void main() { char str[ ]=”I love china!”; char *p; int i; p=str； for (i=0;*(p+i)!=’＼0’;i++) printf(“%c”,*(p+i)); } 或用指针变量整体输出字符数组的值。 void main() { char str[ ]=”I love china!”; char *p; int i; p=str； printf(“%s”,p); } 也可以在定义字符指针的同时初始化。 { char *str=“I love china!”; printf(“%s＼n”,str);
![(2)用字符指针实现 将字符串的首地址赋给指针，用字符指针变量来处理字符串。 【例9.16】 用指针变量逐个输出数组中的每个字符。 void main() { char str[ ]= I love china! ;](http://slidesplayer.com/slide/16239889/95/images/43/%282%29%E7%94%A8%E5%AD%97%E7%AC%A6%E6%8C%87%E9%92%88%E5%AE%9E%E7%8E%B0+%E5%B0%86%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%9A%84%E9%A6%96%E5%9C%B0%E5%9D%80%E8%B5%8B%E7%BB%99%E6%8C%87%E9%92%88%EF%BC%8C%E7%94%A8%E5%AD%97%E7%AC%A6%E6%8C%87%E9%92%88%E5%8F%98%E9%87%8F%E6%9D%A5%E5%A4%84%E7%90%86%E5%AD%97%E7%AC%A6%E4%B8%B2%E3%80%82+%E3%80%90%E4%BE%8B9.16%E3%80%91+%E7%94%A8%E6%8C%87%E9%92%88%E5%8F%98%E9%87%8F%E9%80%90%E4%B8%AA%E8%BE%93%E5%87%BA%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E6%AF%8F%E4%B8%AA%E5%AD%97%E7%AC%A6%E3%80%82+void+main%28%29+%7B+char+str%5B+%5D%3D+I+love+china%21+%3B.jpg "char *p; int i; p=str； for (i=0;*(p+i)!=’＼0’;i++) printf( %c ,*(p+i)); } 或用指针变量整体输出字符数组的值。 void main() { char str[ ]= I love china! ; char *p; int i; p=str； printf( %s ,p); } 也可以在定义字符指针的同时初始化。 { char *str= I love china! ; printf( %s＼n ,str);")
44
【例9.17】 将字符串a复制到字符串b。 void main() { char a[ ]=”I love china!”;
char b[20]; int i; for (i=0;*(a+i)!=’\0’;i++) *(b+i)=*(a+i); *(b+i)=’\0’; printf(“%s\n”,a); for (i=0;b[i]!=’\0’;i++) printf(“%c”,b[i]); } 用指针变量处理例9.17问题。程序如下： void main() { char a[ ]=”I love china!”,b[20],*p1,*p2; int i; p1=a;p2=b; for (;*p1!=’\0’;p1++,p2++) *p2=*p1; *p2=’\0’; printf(“%s\n”,a); for (i=0;b[i]!=’\0’;i++) printf(“%c”,b[i]); } 运行结果： I love china!
![【例9.17】 将字符串a复制到字符串b。 void main() { char a[ ]= I love china! ;](http://slidesplayer.com/slide/16239889/95/images/44/%E3%80%90%E4%BE%8B9.17%E3%80%91+%E5%B0%86%E5%AD%97%E7%AC%A6%E4%B8%B2a%E5%A4%8D%E5%88%B6%E5%88%B0%E5%AD%97%E7%AC%A6%E4%B8%B2b%E3%80%82+void+main%28%29+%7B+char+a%5B+%5D%3D+I+love+china%21+%3B.jpg "char b[20]; int i; for (i=0;*(a+i)!=’\0’;i++) *(b+i)=*(a+i); *(b+i)=’\0’; printf( %s\n ,a); for (i=0;b[i]!=’\0’;i++) printf( %c ,b[i]); } 用指针变量处理例9.17问题。程序如下： void main() { char a[ ]= I love china! ,b[20],*p1,*p2; int i; p1=a;p2=b; for (;*p1!=’\0’;p1++,p2++) *p2=*p1; *p2=’\0’; printf( %s\n ,a); for (i=0;b[i]!=’\0’;i++) printf( %c ,b[i]); } 运行结果： I love china!")
45
字符数组名可作函数参数，字符指针变量也可作函数参数。
2.字符指针作函数参数 字符数组名可作函数参数，字符指针变量也可作函数参数。 【例9.18】 用函数调用实现字符串的连接。 strcat12(char *p1,char *p2) { while (*p1!=’\0’) /*使p1指向第一个字符串末尾*/ p1++; while (*p2!=’\0’) /*将p2连接到第一个字符串的当前位置*/ { *p1=*p2;p1++;p2++; } *p1=’\0’; } void main() char str1[40]={“People’s Republic of ”}; char str2[ ]={“China”}; strcat12(str1,str2); printf(“%s\n”,str1); 运行结果： People’s Republic of China
46
字符数组和字符指针变量都能实现字符串的存储与运算，但两者之间还是有区别的，主要包括以下几点：
3.字符指针变量与字符数组 字符数组和字符指针变量都能实现字符串的存储与运算，但两者之间还是有区别的，主要包括以下几点： (1) 字符数组由若干元素组成，每个元素存放一个字符； 字符指针变量存放的是字符串的首地址。 (2) 赋值方式不同： 不能用赋值语句给字符数组赋值。 char str[14]; str=“I love china!” 这是错误的。 字符指针变量可以采用下面的形式赋值： char *p； p=“china!” 这是正确的。 但要注意赋给指针变量p的不是字符串，而是字符串的首地址。 (3)定义一个数组，在编译时分配存放n个元素的存储空间； 定义指针变量只分配存放一个地址的空间。 (4)指针变量的值是可以改变的，字符数组名则不行。
47
【例9.19】字符指针变化输出。 void main() { char *a=“I love China!”; a=a+7; /* a已指向了字符C*/ printf(“%s”,a); } 运行结果如下： China! /*当前地址直到字符串结束为止*/ 字符数组不能采用如下形式： char str[]={“I love China!”}; str=str+7; /*该语句是错误的*/ printf(“%s”,str); 数组名是一个常量其值是不能改变的。 (5) 可以用指针变量指向一个格式字符串，用它代替printf中的格式串。 char *format=“a=%d,b=%f\n”; printf(format ,a,b)
48
9.3.3 指针数组 指针数组：数组的所有元素都是存放指针的数组称为指针数组。 即：指针数组中每一个元素（下标变量）都是指针变量。
指针数组的定义形式： <存储类型> <数据类型> <*指针数组名>[数组长度][={地址列表}]； 例如： Staic int *p[4]; 由于[ ]比*的优先级高，先构成p[4]数组形式，有4 个元素:p[0],p[1],p[2],p[3]。然后再与p前面的“*”结合成为指针数组。 指针数组的用途：每个元素存放一个字符串首址，使得在处理多个字符串时非常方便。
49
例如：图书馆有下列一些书籍，Visual BASIC、QBASIC、Pascal、C、Visual Foxpro等 ，将这些书名进行排序。
处理方法： 先定义一个二维数组存放这些书名。 char ch[ ][14]; 存储空间如图9.9所示。 ch[0]VisualBASIC\0Ch[1]QBASIC\0Ch[2]Pascal\0Ch[3]C\0Ch[4]VisualFoxpro\0图9.9 字符数组ch[][14] 存储空间 图9.9 字符数组ch[ ][14] 存储空间
50
(2)定义一个指针数组 例如定义： char *p[5]; for(i=0;i<5;i++) p[i]=ch[i]; 存储空间如图9.10所示。 或： char *p[5]={“Visual BASIC”,”Qbsic”,”Pascal”,”C”,”Visual Foxpro” }; 【例9.20】 将若干字符串按字母顺序由小到大排序。 程序思想：以上面图书馆书籍名称排序为例，只需改变指针数组的指向，使其指针所指的字符串按字母从小到大排序即可。
![(2)定义一个指针数组 例如定义： char *p[5]; for(i=0;i<5;i++) p[i]=ch[i]; 存储空间如图9.10所示。 或： char *p[5]={ Visual BASIC , Qbsic , Pascal , C , Visual Foxpro };](http://slidesplayer.com/slide/16239889/95/images/50/%282%29%E5%AE%9A%E4%B9%89%E4%B8%80%E4%B8%AA%E6%8C%87%E9%92%88%E6%95%B0%E7%BB%84+%E4%BE%8B%E5%A6%82%E5%AE%9A%E4%B9%89%EF%BC%9A+char+%2Ap%5B5%5D%3B+for%28i%3D0%3Bi%3C5%3Bi%2B%2B%29+p%5Bi%5D%3Dch%5Bi%5D%3B+%E5%AD%98%E5%82%A8%E7%A9%BA%E9%97%B4%E5%A6%82%E5%9B%BE9.10%E6%89%80%E7%A4%BA%E3%80%82+%E6%88%96%EF%BC%9A+char+%2Ap%5B5%5D%3D%7B+Visual+BASIC+%2C+Qbsic+%2C+Pascal+%2C+C+%2C+Visual+Foxpro+%7D%3B.jpg "【例9.20】 将若干字符串按字母顺序由小到大排序。 程序思想：以上面图书馆书籍名称排序为例，只需改变指针数组的指向，使其指针所指的字符串按字母从小到大排序即可。")
51
程序如下： #include <string.h> void sort (char *xname[ ],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(xname[k],xname[j])>0) k=j; if (k!=i) { temp=xname[i]; xname[i]=xname[k]; xname[k]=temp; } }
![程序如下： #include <string.h> void sort (char *xname[ ],int n) { char *temp; int i,j,k; for (i=0;i<n-1;i++)](http://slidesplayer.com/slide/16239889/95/images/51/%E7%A8%8B%E5%BA%8F%E5%A6%82%E4%B8%8B%EF%BC%9A+%23include+%3Cstring.h%3E+void+sort+%28char+%2Axname%5B+%5D%2Cint+n%29+%7B+char+%2Atemp%3B+int+i%2Cj%2Ck%3B+for+%28i%3D0%3Bi%3Cn-1%3Bi%2B%2B%29.jpg "k=i; for (j=i+1;j<n;j++) if (strcmp(xname[k],xname[j])>0) k=j; if (k!=i) { temp=xname[i]; xname[i]=xname[k]; xname[k]=temp; } }")
52
void main() { Char *name[ ]={“Visual BASIC”,”QBasic”,”Pascal”,”C”,”Visual Foxpro” }; int n=5; sort(name,n); for (i=0;i<n;i++) printf(“%s\n”,name[i]); } 运行结果： C Pascal QBasic Visual BASIC Visual Foxpro
![void main() { Char *name[ ]={ Visual BASIC , QBasic , Pascal , C , Visual Foxpro }; int n=5; sort(name,n);](http://slidesplayer.com/slide/16239889/95/images/52/void+main%28%29+%7B+Char+%2Aname%5B+%5D%3D%7B+Visual+BASIC+%2C+QBasic+%2C+Pascal+%2C+C+%2C+Visual+Foxpro+%7D%3B+int+n%3D5%3B+sort%28name%2Cn%29%3B.jpg "for (i=0;i<n;i++) printf( %s\n ,name[i]); } 运行结果： C. Pascal. QBasic. Visual BASIC. Visual Foxpro.")
53
9.4 函数与指针 9.4.1函数指针 函数名就代表函数的入口地址。 函数指针：函数的入口地址称为函数指针。即指向函数的指针变量为函数指针。
函数指针定义格式： <存储类型> <数据类型> （*指针变量名）（）； 其中：“存储类型”是函数指针本身的存储类型； “数据类型”是指函数返回值的数据类型； 例如： int (*p)(); 定义一个指向整形函数的指针变量p。
54
【例9.21】 求a和b中的最大者。 程序如下： void main() { int max(); int (*p)(); int a,b,c; p=max; /*函数max入口地址赋给p*/ scanf(“%d,%d”,&a,&b); c=(*p)(a,b); printf(“a=%d,b=%d,max=%d”,a,b,c); } int max(int x,int y) { int z; if (x>y) z=x; else z=y; return(z);
55
9.4.2指针函数 指针函数：返回指针值的函数称为指针函数。 指针函数定义形式：
<类型标识符> <*函数名>（参数表）； 例如： int *f1(x,y); 其中f1为函数名，调用f1后得到一个指向整型数据的指针（地址）。 【例9.22】 有若干个学生成绩（每个学生有4门课），要求在用户输入学号后，能输出学生的全部成绩，用指针函数实现。
56
程序如下： void main() { float score[ ][4]={{66,76,86,96},{66,77,88,99},{48,78,89,90}}; float *serach(float(*pointer)[4],int n); float *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++) /*输出第n个学生的全部成绩*/ printf(“%6.2f”,*(p+i)); }
![程序如下： void main() { float score[ ][4]={{66,76,86,96},{66,77,88,99},{48,78,89,90}}; float *serach(float(*pointer)[4],int n);](http://slidesplayer.com/slide/16239889/95/images/56/%E7%A8%8B%E5%BA%8F%E5%A6%82%E4%B8%8B%EF%BC%9A+void+main%28%29+%7B+float+score%5B+%5D%5B4%5D%3D%7B%7B66%2C76%2C86%2C96%7D%2C%7B66%2C77%2C88%2C99%7D%2C%7B48%2C78%2C89%2C90%7D%7D%3B+float+%2Aserach%28float%28%2Apointer%29%5B4%5D%2Cint+n%29%3B.jpg "float *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++) /*输出第n个学生的全部成绩*/ printf( %6.2f ,*(p+i)); }")
57
float *search(float (*pointer)[4],int n)
/*函数的返回值为指向实型数据的指针*/ { float *pt; pt=*(pointer+n); /*把指针定位在第n个学生的第一个数据上*/ return(pt); /*函数的放回值为第n个学生成绩的首地址*/ } 运行结果如下： Enter the number of student:1 The scores of No.%d are: 66.00,77.00,88.00,99.00
![float *search(float (*pointer)[4],int n)](http://slidesplayer.com/slide/16239889/95/images/57/float+%2Asearch%28float+%28%2Apointer%29%5B4%5D%2Cint+n%29.jpg "/*函数的返回值为指向实型数据的指针*/ { float *pt; pt=*(pointer+n); /*把指针定位在第n个学生的第一个数据上*/ return(pt); /*函数的放回值为第n个学生成绩的首地址*/ } 运行结果如下： Enter the number of student:1. The scores of No.%d are: 66.00,77.00,88.00,")
58
9.4.3指向指针的指针 指针变量:专门用来存放另一个变量的地址的变量就称为指针变量；
指向指针的指针:用来存放指针变量的地址的变量就称为指向指针变量的指针变量。有的教材又称为二级指针变量。 定义格式： <类型标识符> **变量名； 例如：int **p;
59
【例9.24】 void main() { int a=12; int *p1,**p2; p1=&a; p2=&p1; printf(“%d,%d\n”,*p1,**p2); } 运行结果： 12,12
60
9.5 程序综合举例 假设每班人数最多不超过40人，具体人数由键盘输入，试编程打印最高分及其学号。
【例9.26】 用一维数组和指针变量作为函数参数，编程打印某班一门课成绩的最高分及其学号。 #include <stdio.h> #define ARR_SIZE 40 int FindMax(int score[], long num[], int n, long *pMaxNum); void main() { int score[ARR_SIZE], maxScore, n, i; long num[ARR_SIZE], maxNum; printf("Please enter total number:"); scanf("%d", &n); /*从键盘输入学生人数n*/ printf("Please enter the number and score:\n"); for(i=0; i<n; i++) /*输入学生的学号和成绩*/ { scanf("%ld%d", &num[i], &score[i]); } maxScore = FindMax(score, num, n, &maxNum); printf("maxScore = %d, maxNum = %ld\n", maxScore, maxNum); }
61
/* 函数功能：计算最高分及最高分学生的学号*/
int FindMax(int score[ ], long num[ ], int n, long *pMaxNum) { int i; int maxScore; maxScore = score[0]; /*假设score[0]为最高分*/ *pMaxNum = num[0]; for (i=1; i<n; i++) if (score[i] > maxScore) { maxScore = score[i]; /*记录最高分*/ *pMaxNum = num[i]; /*记录最高分学生的学号*/ } return (maxScore); /*返回最高分maxScore*/
62
【例9.27】 用二维数组和指针变量作为函数参数，编程打印3个班学生（假设每班4个学生）的某门课成绩的最高分，并指出具有该最高分成绩的学生是第几个班的第几个学生。
程序如下： #include <stdio.h> #define CLASS 3 #define STU 4 int FindMax(int score[CLASS][STU], int m, int *pRow, int *pCol); void main() { int score[CLASS][STU], i, j, maxScore, row, col; printf("Please enter score:\n"); for (i=0; i<CLASS; i++) for (j=0; j<STU; j++) scanf("%d", &score[i][j]); /*输入学生成绩*/
63
maxScore = FindMax(score, CLASS, &row, &col);
printf("maxScore = %d, class = %d, number = %d\n",maxScore, row+1, col+1); } int FindMax(int score[ ][STU], int m, int *pRow, int *pCol) { int i, j, maxScore; maxScore = score[0][0]; /*置初值，假设第一个元素值最大*/ *pRow = 0; *pCol = 0; for (i = 0; i<m; i++) for (j = 0; j<STU; j++) if (score[i][j] > maxScore) {maxScore = score[i][j]; /*记录当前最大值*/ *pRow = i; /*记录行下标*/ *pCol = j; } /*记录列下标*/ return (maxScore); /*返回最高分*/
64
9.6上机实训 实训1 1.实训目的 (1)掌握指针变量的定义与引用。 (2)掌握指针与变量、指针与数组的关系。
(3)掌握用数组指针作为函数参数的方法。 (4)熟悉集成环境的调试指针程序的方法。 2.实训内容 以下均用指针方法编程: (1)下面程序有部分错误，调试下列程序，使之具有如下功能： 用指针法输入12个数，然后按每行4个数输出。写出调试过程。
65
void main() { int j,k,a[12],*p； for(j=0；j<12；j++) scanf("%d",p++)； { printf("%d",*p++)； if(j%4 == 0) printf("\n")； } (2)调试此程序时将a、p、*p设置为"watch"，调试时注意指针变量指向哪个目标变量。 (3)编写一个函数void sort(int *,int count)，接收主程序中数组，并按照从小到大的顺序对数组中的元素排序。 (4)自己编写一个比较两个字符串s和t大小的函数strcomp(char *s,char *t)，要求s小于t时返回-1，s等于t时返回0，s大于t时返回1。在主函数中任意输入4个字符串，利用该函数求最小字符串。
![void main() { int j,k,a[12],*p； for(j=0；j<12；j++) scanf( %d ,p++)； { printf( %d ,*p++)； if(j%4 == 0)](http://slidesplayer.com/slide/16239889/95/images/65/void+main%28%29+%7B+int+j%2Ck%2Ca%5B12%5D%2C%2Ap%EF%BC%9B+for%28j%3D0%EF%BC%9Bj%3C12%EF%BC%9Bj%2B%2B%29+scanf%28+%25d+%2Cp%2B%2B%29%EF%BC%9B+%7B+printf%28+%25d+%2C%2Ap%2B%2B%29%EF%BC%9B+if%28j%254+%3D%3D+0%29.jpg "printf( \n )； } (2)调试此程序时将a、p、*p设置为 watch ，调试时注意指针变量指向哪个目标变量。 (3)编写一个函数void sort(int *,int count)，接收主程序中数组，并按照从小到大的顺序对数组中的元素排序。 (4)自己编写一个比较两个字符串s和t大小的函数strcomp(char *s,char *t)，要求s小于t时返回-1，s等于t时返回0，s大于t时返回1。在主函数中任意输入4个字符串，利用该函数求最小字符串。")
66
3.实验要求 (1)复习指针的定义与使用方法。 (2)编写程序，运行程序并记录运行结果。
(3)将源程序、目标文件、可执行文件和实验报告存在服务器的指定文件夹。
Similar presentations
![第六节 二维数组和指针 二维数组的地址 对于一维数组: （1）数组名array表示数组的首地址， 即array[0]的地址；](/65/11719625/big_thumb.jpg "第六节 二维数组和指针 二维数组的地址 对于一维数组: （1）数组名array表示数组的首地址， 即array[0]的地址；>")
