C语言教案第9章.docx

C语言教案第9章.docx

《C语言教案第9章.docx》由会员分享，可在线阅读，更多相关《C语言教案第9章.docx（34页珍藏版）》请在冰豆网上搜索。

C语言教案第9章

●复习

变量的定义和使用。

●新授

第九章　指针

指针是Ｃ语言中的重要概念，也是Ｃ语言的重要特色。

使用指针，可以使程序更加简洁、紧凑、高效。

9.1指针和指针变量的概念

一、内存地址──内存中存储单元的编号

（1）计算机硬件系统的内存储器中，拥有大量的存储单元（容量为１字节）。

为了方便管理，必须为每一个存储单元编号，这个编号就是存储单元的“地址”。

每个存储单元都有一个唯一的地址。

（2）在地址所标识的存储单元中存放数据。

注意：

内存单元的地址与内存单元中的数据是两个完全不同的概念。

二、变量地址──系统分配给变量的内存单元的起始地址

假设有这样一个程序：

main（）

{intnum;

scanf（"%d",&num）;

printf（"num=%d\n",num）;

}

C编译程序编译到该变量定义语句时，将变量num登录到“符号表”中。

符号表的关键属性有两个：

一是“标识符名（id）”，二是该标识符在内存空间中的“地址（addr）”。

为描述方便，假设系统分配给变量num的2字节存储单元为3000和3001，则起始地址3000就是变量num在内存中的地址。

三、变量值的存取──通过变量在内存中的地址进行

系统执行“scanf（”%d“,&num）;”和“printf（”num=%d\n“,num）;”时，存取变量num值的方式可以有两种：

（1）直接访问──直接利用变量的地址进行存取

1）上例中scanf（“%d”,&num）的执行过程是这样的：

用变量名num作为索引值，检索符号表，找到变量num的起始地址3000；然后将键盘输入的值（假设为３）送到内存单元3000和3001中。

此时，变量num在内存中的地址和值，如图9-1所示。

P136

2）printf（"num=%d\n",num）的执行过程，与scanf（）很相似：

首先找到变量num的起始地址3000，然后从3000和3001中取出其值，最后将它输出。

（2）间接访问──通过另一变量访问该变量的值

Ｃ语言规定：

在程序中可以定义一种特殊的变量（称为指针变量），用来存放其它变量的地址。

例如，假设定义了这样一个指针变量num_pointer，它被分配到4000、4001单元，其值可通过赋值语句“num_pointer=＆num；”得到。

此时，指针变量num_pointer的值就是变量num在内存中的起始地址3000，如图9-1所示。

通过指针变量num_pointer存取变量num值的过程如下：

首先找到指针变量num_pointer的地址（4000），取出其值3000（正好是变量num的起始地址）；然后从3000、3001中取出变量num的值（3）。

（3）两种访问方式的比较

两种访问方式之间的关系，可以用某人甲（系统）要找某人乙（变量）来类比。

一种情况是，甲知道乙在何处，直接去找就是（即直接访问）。

另一种情况是，甲不知道乙在哪，但丙（指针变量）知道，此时甲可以这么做：

先找丙，从丙处获得乙的去向，然后再找乙（即间接访问）。

四、指针与指针变量

（1）指针──即地址

一个变量的地址称为该变量的指针。

通过变量的指针能够找到该变量。

（2）指针变量──专门用于存储其它变量地址的变量

指针变量num_pointer的值就是变量num的地址。

指针与指针变量的区别，就是变量值与变量的区别。

（3）为表示指针变量和它指向的变量之间的关系，用指针运算符“*”表示。

例如，指针变量num_pointer与它所指向的变量num的关系，表示为：

*num_pointer，即*num_pointer等价于变量num。

因此，下面两个语句的作用相同：

num=3;/*将3直接赋给变量num*/

num_pointer=#/*使num_pointer指向num*/

*num_pointer=3;/*将3赋给指针变量num_pointer所指向的变量*/

9.2指针变量的定义与应用

9.2.1指针变量的定义与相关运算

[案例9.1]指针变量的定义与相关运算示例。

/*案例代码文件名：

AL9_1.C*/

main（）

{intnum_int=12,*p_int;/*定义指向int型数据的指针变量p_int*/

floatnum_f=3.14,*p_f;/*定义指向float型数据的指针变量p_f*/

charnum_ch=’p’,*p_ch;/*定义指向char型数据的指针变量p_ch*/

p_int=&num_int;/*取变量num_int的地址，赋值给p_int*/

p_f=&num_f;/*取变量num_f的地址，赋值给p_f*/

p_ch=&num_ch;/*取变量num_ch的地址，赋值给p_ch*/

printf（“num_int=%d,*p_int=%d\n”,num_int,*p_int）;

printf（“num_f=%4.2f,*p_f=%4.2f\n”,num_f,*p_f）;

printf（“num_ch=%c,*p_ch=%c\n”,num_ch,*p_ch）;

}

程序运行结果：

num_int=12,*p_int=12

num_f=3.14,*p_f=3.14

num_ch=p,*p_ch=p

程序说明：

（1）头三行的变量定义语句──指针变量的定义

与一般变量的定义相比，除变量名前多了一个星号“*”（指针变量的定义标识符）外，其余一样：

数据类型*指针变量[,*指针变量2……];

注意：

此时的指针变量p_int、p_f、p_ch，并未指向某个具体的变量（称指针是悬空的）。

使用悬空指针很容易破坏系统，导致系统瘫痪。

（2）中间三行的赋值语句──取地址运算（＆）

取地址运算的格式：

＆变量

例如，&num_int、&num_f、&num_ch的结果，分别为变量num_int、num_f、num_ch的地址。

注意：

指针变量只能存放指针（地址），且只能是相同类型变量的地址。

例如，指针变量p_int、p_f、p_ch，只能分别接收int型、float型、char型变量的地址，否则出错。

（3）后三行的输出语句──指针运算（*）

使用直接访问和间接访问两种方式，分别输出变量num_int、num_f、num_ch的值。

注意：

这三行出现在指针变量前的星号“*”是指针运算符，访问指针变量所指向的变量的值，而非指针运算符。

[案例9.2]使用指针变量求解：

输入2个整数，按升序（从小到大排序）输出。

/*案例代码文件名：

AL9_2.C*/

/*程序功能：

使用指针变量求解2个整数的升序输出*/

main（）

{intnum1,num2;

int*num1_p=&num1,*num2_p=&num2,*pointer;

printf（“Inputthefirstnumber:

”）;

scanf（“%d”,num1_p）;

printf（“Inputthesecondnumber:

”）;

scanf（“%d”,num2_p）;

printf（“num1=%d,num2=%d\n”,num1,num2）;

if（*num1_p>*num2_p）/*如果num1>num2，则交换指针*/

pointer=num1_p,num1_p=num2_p,num2_p=pointer;

printf（“min=%d,max=%d\n”,*num1_p,*num2_p）;

}

程序运行情况：

Inputthefirstnumber:

9←┘

Inputthesecondnumber:

6←┘

num1=9,num2=6

min=6,max=9

程序说明：

（1）第5行的if语句

如果*num1_p>*num2_p（即num1>num2），则交换指针，使num1_p指向变量num2（较小值），num2_p指向变量num1（较大值）。

（2）printf（“min=%d,max=%d\n”,*num1_p,*num2_p）;语句：

通过指针变量，间接访问变量的值。

9.2.2指针变量作函数参数

1、指针变量，既可以作为函数的形参，也可以作函数的实参。

2、指针变量作实参时，与普通变量一样，也是“值传递”，即将指针变量的值（一个地址）传递给被调用函数的形参（必须是一个指针变量）。

[案例9.3]使用函数调用方式

改写[案例9.2]，要求实参为指针变量。

/*案例代码文件名：

AL9_3.C*/

/******************************************************/

/*exchange（）功能：

交换2个形参指针变量所指向的变量的值*/

/*形参：

2个，均为指向整型数据的指针变量*/

/*返回值：

无*/

/******************************************************/

voidexchange（int*pointer1,int*pointer2）

{inttemp;

temp=*pointer1,*pointer1=*pointer2,*pointer2=temp;

}

/*主函数main（）*/

main（）

{intnum1,num2;

/*定义并初始化指针变量num1_p和num2_p*/

int*num1_p=&num1,*num2_p=&num2;

printf（“Inputthefirstnumber:

”）;

scanf（“%d”,num1_p）;

printf（“Inputthesecondnumber:

”）;

scanf（“%d”,num2_p）;

printf（“num1=%d,num2=%d\n”,num1,num2）;

if（*num1_p>*num2_p）/*即num1>num2）*/

exchange（num1_p,num2_p）;/*指针变量作实参*/

/*输出排序后的num1和num2的值*/

printf（“min=%d,max=%d\n”,num1,num2）;

}

程序运行情况：

Inputthefirstnumber:

9←┘

Inputthesecondnumber:

6←┘

num1=9,num2=6

min=6,max=9

程序说明：

1、调用函数exchange（）之前、之时、结束时和结束后的情况，如图9-5所示。

2、形参指针变量pointer1（指向变量num1）和pointer2（指向变量num2），在函数调用开始时才分配存储空间，函数调用结束后立即被释放。

3、虽然被调用函数不能改变实参指针变量的值，但可以改变它们所指向的变量的值。

[案例9.4]输入3个整数，按降序（从大到小的顺序）输出。

要求使用变量的指针作函数调用的实参来实现。

/*案例代码文件名：

AL9_4.C*/

/******************************************************/

/*exchange（）功能：

交换2个形参指针变量所指向的变量的值*/

/*形参：

2个，均为指向整型数据的指针变量*/

/*返回值：

无*/

/******************************************************/

voidexchange（int*pointer1,int*pointer2）

{inttemp;

temp=*pointer1,*pointer1=*pointer2,*pointer2=temp;

}

/*主函数main（）*/

main（）

{intnum1,num2,num3;

/*从键盘上输入3个整数*/

printf（“Inputthefirstnumber:

”）;scanf（“%d”,&num1）;

printf（“Inputthesecondnumber:

”）;scanf（“%d”,&num2）;

printf（“Inputthethirdnumber:

”）;scanf（“%d”,&num3）;

printf（“num1=%d,num2=%d,num3=%d\n”,num1,num2,num3）;

/*排序*/

if（num1

exchange（&num1,&num2）;

if（num1

if（num2

/*输出排序结果*/

printf（“排序结果:

%d,%d,%d\n”,num1,num2,num3）;

}

程序运行情况：

Inputthefirstnumber:

9←┘

Inputthesecondnumber:

6←┘

Inputthethirdnumber:

12←┘

num1=9,num2=6,num3=12

排序结果:

12,9,6

●小结

指针与指针变量的概念，指针变量的定义及使用。

●作业

●复习

指针变量的定义及使用，数组的定义和使用

●新授

9.3数组的指针和指向数组的指针变量

9.3.1概述

1、概念

数组的指针──数组在内存中的起始地址。

数组元素的指针──数组元素在内存中的起始地址。

2、指向数组的指针变量的定义

指向数组的指针变量的定义，与指向普通变量的指针变量的定义方法一样。

例如，intarray[10],*pointer=array（或&array[0]）;

或者：

intarray[10],*pointer;

　　　pointer＝array;

3、数组元素的引用

数组元素的引用，既可用下标法，也可用指针法。

使用下标法，直观；而使用指针法，能使目标程序占用内存少、运行速度快。

9.3.2通过指针引用数组元素

如果有“intarray[10],*pointer=array;”，则：

（1）pointer+i和array+i都是数组元素array[i]的地址，如图9-6所示。

（2）*（pointer+i）和*（array+i）就是数组元素array[i]。

（3）指向数组的指针变量，也可将其看作是数组名，因而可按下标法来使用。

例如，pointer[i]等价于*（pointer+i）。

例如，假设指针变量pointer的当前值为3000，则pointer+1为3000+1*2=3002，而不是3001。

[案例9.5]使用指向数组的指针变量来引用数组元素。

/*案例代码文件名：

AL9_5.C*/

/*程序功能：

使用指向数组的指针变量来引用数组元素*/

main（）

{intarray[10],*pointer=array,i;

printf（“Input10numbers:

”）;

for（i=0;i<10;i++）

scanf（“%d”,pointer+i）;/*使用指针变量来输入数组元素的值*/

printf（“array[10]:

”）;

for（i=0;i<10;i++）

printf（“%d”,*（pointer+i））;/*使用指向数组的指针变量输出数组*/

printf（“\n”）;

}

程序运行情况：

Input10numbers:

0123456789←┘

array[10]:

0123456789

程序说明：

程序中第3行和第6行的2个for语句，等价于下面的程序段：

for（i=0;i<10;i++,pointer++）

scanf（“%d”,pointer）;

printf（“array[10]:

”）;

pointer=array;/*使pointer重新指向数组的第一个元素*/

for（i=0;i<10;i++,pointer++）

printf（“%d”,*pointer）;

思考题：

（1）如果去掉“pointer=array;”行，程序运行结果会如何？

请上机验证。

（2）在本案例中，也可以不使用i来作循环控制变量，程序怎么修改？

提示：

指针可以参与关系运算。

说明：

（1）指针变量的值是可以改变的，所以必须注意其当前值，否则容易出错。

（2）指向数组的指针变量，可以指向数组以后的内存单元，虽然没有实际意义。

（3）对指向数组的指针变量（px和py）进行算术运算和关系运算的含义

1）可以进行的算术运算，只有以下几种：

px±n,px++/++px,px--/--px,px-py

px±n：

将指针从当前位置向前（+n）或回退（-n）n个数据单位，而不是n个字节。

显然，px++/++px和px--/--px是px±n的特例（n=1）。

px-py：

两指针之间的数据个数，而不是指针的地址之差。

2）关系运算

表示两个指针所指地址之间、位置的前后关系：

前者为小，后者为大。

例如，如果指针px所指地址在指针py所指地址之前，则px〈py的值为1。

9.3.3再论数组作函数参数

数组名作形参时，接收实参数组的起始地址；作实参时，将数组的起始地址传递给形参数组。

引入指向数组的指针变量后，数组及指向数组的指针变量作函数参数时，可有４种等价形式（本质上是一种，即指针数据作函数参数）：

（1）形参、实参都用数组名

（2）形参、实参都用指针变量

（3）形参用指针变量、实参用数组名

（4）形参用数组名、实参用指针变量

9.3.42维数组的指针及其指针变量

1、2维数组的指针

假设有如下数组定义语句：

intarray[3][4];

（1）从2维数组角度看，数组名array代表数组的起始地址，是一个以行为单位进行控制的行指针：

array+i：

行指针值，指向2维数组的第i行。

*（array+i）：

（列）指针值，指向第i行第０列（控制由行转为列，但仍为指针）。

*（*（array+i））：

数组元素array[i][0]的值。

用array作指针访问数组元素array[i][j]的格式：

*（*（array+i）＋j）

（2）从1维数组角度看，数组名array和第1维下标的每一个值，共同构成一组新的1维数组名array[0]、array[1]、array[2]，它们均由4个元素组成。

Ｃ语言规定：

数组名代表数组的地址，所以array[i]是第i行1维数组的地址，它指向该行的第0列元素，是一个以数组元素为单位进行控制的列指针：

array[i]+j：

（列）指针值，指向数组元素array[i][j]。

*（array[i]+j）：

数组元素array[i][j]的值。

如果有“intarray[3][4],*p=array[0]；”，则p+1指向下一个元素，如图9-8所示。

用p作指针访问数组元素array[i][j]的格式：

*（p+（ｉ*每行列数+j））

2、行指针变量──指向由n个元素组成的一维数组的指针变量

（1）定义格式

数据类型（*指针变量）[n];

（2）赋值

行指针变量＝2维数组名|行指针变量;

[案例9.6]使用行指针和列指针两种方式输出2维数组的任一元素。

（1）使用行指针

/*案例代码文件名：

AL9_6_1.C*/

/*程序功能：

使用行指针输出2维数组的任一元素*/

main（）

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

int（*pointer）[4],row,col;

pointer=array;

printf（“Inputrow=”）;scanf（“%d”,&row）;

printf（“Inputcol=”）;scanf（“%d”,&col）;

printf（“array[%1d][%1d]=%d\n”,row,col,*（*（pointer+row）+col））;

}

程序运行情况：

Inputrow=1←┘

Inputcol=2←┘

array[1][2]=7

思考题：

本题也可以直接使用数组名array作指针，应如何修改？

（2）使用列指针

/*案例代码文件名：

AL9_6_2.C*/

/*程序功能：

使用列指针输出2维数组的任一元素*/

main（）

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

int*pointer,row,col;/*定义一个（列）指针变量pointer*/

pointer=array[0];/*给（列）指针变量pointer赋值*/

printf（“Inputrow=”）;scanf（“%d”,&row）;

printf（“Inputcol=”）;scanf（“%d”,&col）;

printf（“array[%1d][%1d]=%d\n”,row,col,*（pointer+（row*4+col）））;

}

3、2维数组指针作函数参数

2维数组的指针作函数实参时，有列指针和行指针两种形式。

相应的，用来接受实参数组指针的形参，必须使用相应形式的指针变量，如下所示：

实参：

列指针行指针

↓↓

形参：

（列）指针变量行指针变量

9.3.5动态数组的实现

在程序运行过程中，数组的大小是不能改变的。

这种数组称为静态数组。

静态数组的缺点是：

对于事先无法准确估计数据量的情况，无法做到既满足处理需要，又不浪费内存空间。

所谓动态数组是指，在程序运行过程中，根据实际需要指定数组的大小。

在C语言中，可利用内存的申请和释放库函数，以及指向数组的指针变量可当数组名使用的特点，来实现动态数组。

动态数组的本质是：

一个指向数组的指针变量。

[案例9.7]动态数组的实现。

/*案例代码文件名：

AL9_7.C*/

/*程序功能：

实现动态数组*/

#include“alloc.h”

#include“stdlib.h”

main（）

{int*array=NULL,num,i;

　printf（“Inputthenumberofelement:

”）;scanf（“%d”,&num）;

/*申请动态数组使用的内存块*/

array=（int*）malloc（sizeof（int）*num）;

if（array==NULL）/*内存申请失败：

提示，退出*/

{printf（“outofmemory,pressanykeytoquit……”）;

exit（0）;/*exit（）：

终止程序运行，返回操作系统*/