第十章
§ 10.1地址和指针的概念为了说清楚什么是指针，必须弄清楚数据在内存中是如何存储的，又是如何读取的。
内存区的每一个字节有一个编号，这就是,地址,。
如果在程序中定义了一个变量，在对程序进行编译时，
系统就会给这个变量分配内存单元。
１、按变量地址存取变量值的方式称为,直接访问,方式
ｐｒｉｎｔｆ（ ″％ｄ ″，ｉ） ;
ｓｃａｎｆ（ ″％ｄ ″，＆ｉ）；
ｋ＝ｉ＋ｊ；
例如：
另一种存取变量值的方式称为,间接访问,的方式。
即，将变量ｉ的地址存放在另一个变量中。
在Ｃ语言中，指针是一种特殊的变量，它是存放地址的。
假设我们定义了一个指针变量 i_pointer用来存放整型变量的地址，它被分配地址为 (3010),(3011)的两个字节。
可以通过语句,i_pointer ＝＆ｉ；
将ｉ的地址 (2000)存放到 i_pointer中。这时,i_pointer
的值就是 (2000),即变量ｉ所占用单元的起始地址。要存取变量ｉ的值，可以采用间接方式：先找到存放“ｉ
的地址”的变量 i_pointer,从中取出ｉ的地址 (2000)，
然后到 2000,200１字节取出ｉ的值（３）。
一个变量的地址称为该变量的,指针,。
例如，地址 2000是变量ｉ的指针。 如果有一个变量专门用来存放另一变量的地址（即指针），则它称为
,指针变量,。上述的 i_pointer就是一个指针变量。
指针和指针变量的定义：
指针变量的值（即指针变量中存放的值）是地址（即指针）。请区分“指针”和“指针变量”
这两个概念。
§ 10.2 变量的指针和指向变量的指针变量
10.２,1 定义一个指针变量定义指针变量的一般形式为基类型 *指针变量名；
下面都是合法的定义：
float *pointer_３； // pointer_３是指向 float型变量的指针变量
char *pointer_４； //pointer_４是指向字符型变量的指针变量可以用赋值语句使一个指针变量得到另一个变量的地址，从而使它指向一个该变量。如：
pointer_１＝＆ｉ；
pointer_２＝＆ｊ；
在定义指针变量时要注意两点：
(1)指针变量前面的,*”,表示该变量的类型为指针型变量。
例,float *pointer_1；
指针变量名是 pointer_1,而不是 * pointer_1 。
(2) 在定义指针变量时必须指定基类型。
需要特别注意的是，只有整型变量的地址才能放到指向整型变量的指针变量中。下面的赋值是错误的 ∶
float a;
int * pointer_1;
pointer_1=&a; /* 将 float型变量的地址放到指向整型变量的指针变量中，错误 */
10.２,２ 指针变量的引用请牢记，指针变量中只能存放地址（指针），
不要将一个整数（或任何其他非地址类型的数据）
赋给一个指针变量。
例 10.１ 通过指针变量访问整型变量
#include <stdio.h>
void main ( )
｛ int ａ，ｂ；
int *pointer_１,*pointer_２；
ａ＝１００；ｂ＝１０；
pointer_１＝＆ａ； /*把变量ａ的地址赋给
pointer_1 */
pointer_２＝＆ｂ； /*把变量ｂ的地址赋给
pointer_２ */
printf（ ″%ｄ,%ｄ \ｎ ″,ａ,ｂ）；
printf（ ″%ｄ,%ｄ \ｎ ″,*pointer_１,*pointer_２）；
｝
对“＆”和,*”运算符说明：
如果已执行了语句 pointer_１＝＆ａ；
(1)＆ * pointer_１ 的含义是什么？“＆”和,*”两个运算符的优先级别相同，但按自右而左方向结合，
因此先进行 * pointer_１ 的运算，它就是变量ａ，再执行＆运算。因此,＆ * pointer_１ 与 ＆ａ 相同，即变量 a的地址。如果有 pointer_2 ＝＆ * pointer_１ ；
它的作用是将＆ａ（ａ的地址）赋给 pointer_2,如果 pointer_2原来指向ｂ，经过重新赋值后它已不再指向ｂ了，而指向了ａ。
(2) *＆ａ的含义是什么？先进行＆ａ运算，得ａ的地址，再进行 *运算。即＆ａ所指向的变量，也就是变量
a。 *＆ａ和 *pointer_１的作用是一样的，它们都等价于变量ａ。即 *＆ａ与ａ等价。
(3) （ *pointer_１）＋＋相当于ａ＋＋。注意括号是必要的，如果没有括号，就成为了 *pointer_１＋＋，从附录可知,++和 *为同一优先级别，而结合方向为自右而左，因此它相当于 *(pointer_１＋＋ )。由于 ++在
pointer_1的右侧，是“后加”，因此先对 pointer_１的原值进行 *运算，得到ａ的值，然后使 pointer_１的值改变，这样 pointer_１不再指向ａ了。
例 10,2 输入ａ和ｂ两个整数，按先大后小的顺序输出
ａ和ｂ。
#include <stdio.h>
void main（）
｛ int *ｐ 1,*ｐ 2,*ｐ，ａ，ｂ；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
ｐ 1＝＆ａ；ｐ２＝＆ｂ；
if（ａ＜ｂ）
｛ｐ＝ｐ１；ｐ１＝ｐ２；ｐ２＝ｐ；｝
printf（ ″ａ =％ｄ,ｂ =％ｄ \ｎ \ｎ ″,ａ,ｂ）；
printf（ ″max=％ｄ,min=％ｄ \ｎ ″,*ｐ 1,*ｐ 2）；
｝
运行情况如下：
５，９ ↙
ａ＝５，ｂ＝９
ｍａｘ＝９，ｍｉｎ＝５
当输入ａ＝５，ｂ＝９时，由于ａ＜ｂ，
将ｐ１和ｐ２交换。交换前的情况见图
（ａ），交换后见图（ｂ）。
10.２,3 指针变量作为函数参数例 10,3 对输入的两个整数按大小顺序输出
#include <stdio.h>
void main（）
｛ void swap（ int *ｐ１,int *ｐ２） ;
int ａ，ｂ；
int *pointer_１,*pointer_２；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
pointer_１ ＝＆ａ； pointer_2 ＝＆ｂ；
if（ａ＜ｂ＝ swap（ pointer_１,pointer_2 ）；
printf（ ″\ｎ％ｄ，％ｄ \ｎ ″，ａ，ｂ）；
｝
void swap（ int *ｐ１,int *ｐ２）
｛ int temp；
temp＝ *ｐ 1；
*ｐ１＝ *ｐ２；
*ｐ２＝ temp；
｝
例 10.４ 输入ａ、ｂ、ｃ 3个整数，按大小顺序输出
#include <stdio.h>
void main（）
｛ void exchange（ int *ｑ 1,int *ｑ 2,int *ｑ 3） ;
int ａ，ｂ，ｃ,*ｐ１,*ｐ２,*ｐ３；
scanf（ ″%ｄ,%ｄ,%ｄ ″,&ａ,&ｂ,&ｃ）；
ｐ１＝＆ａ；ｐ２＝＆ｂ；ｐ３＝＆ｃ；
exchange （ｐ１，ｐ２，ｐ３）；
printf（ ″＼ｎ％ｄ,％ｄ,％ｄ＼ｎ ″,ａ,ｂ,ｃ）；
｝
void exchange（ int *ｑ１,int *ｑ２,int *ｑ３）
｛ void swap（ int *ｐｔ１,int *ｐｔ２） ;
if（ *ｑ１＜ *ｑ２） swap（ｑ１，ｑ２）；
if（ *ｑ１＜ *ｑ３） swap（ｑ１，ｑ３）；
if（ *ｑ２＜ *ｑ３＝ swap（ｑ２，ｑ３）；
｝
void swap（ int *ｐｔ１,int *ｐｔ２）
｛ int temp；
temp＝ *ｐｔ１；
*ｐｔ１＝ *ｐｔ２；
*ｐｔ２＝ temp；
｝
§ 10.3 数组与指针一个变量有地址，一个数组包含若干元素，每个数组元素都在内存中占用存储单元，它们都有相应的地址。指针变量既然可以指向变量，当然也可以指向数组元素（把某一元素的地址放到一个指针变量中）。所谓 数组元素的指针就是数组元素的地址 。
定义一个指向数组元素的指针变量的方法，与以前介绍的指向变量的指针变量相同。例如：
ｉｎｔ ａ［１０］；
(定义ａ为包含１０个整型数据的数组 )
*ｐ；
(定义ｐ为指向整型变量的指针变量 )
应当注意，如果数组为ｉｎｔ型，则指针变量的基类型亦应为ｉｎｔ型。
10.3.1 指向数组元素的指针对该指针变量赋值：
ｐ＝＆ａ［０］；
把ａ［０］元素的地址赋给指针变量ｐ。也就是使ｐ
指向ａ数组的第０号元素，如图：
10.３,２通过指针引用数组元素引用一个数组元素，可以用：
（１） 下标法，如ａ［ｉ］形式；
（２） 指针法，如 *（ａ＋ｉ）或 *（ｐ＋ｉ） 。
其中ａ是数组名，ｐ是指向数组元素的指针变量，其初值ｐ＝ａ。
例 10.5 输出数组中的全部元素假设有一个ａ数组，整型，有１０个元素。要输出各元素的值有三种方法：
(1)下标法
#include <stdio.h>
void main（）
｛ int ａ［１０］；
int ｉ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（ ″％ｄ ″，＆ａ［ｉ］）；
printf（ ″＼ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf（ ″％ｄ ″，ａ［ｉ］）；
｝
(2) 通过数组名计算数组元素地址，找出元素的值。
#include <stdio.h>
void main（）
｛ int ａ［１０］；
int ｉ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋ ）
scanf（ ″％ｄ ″，＆ａ［ｉ］）；
printf（ ″＼ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf（ ″％ｄ ″,*（ａ＋ｉ））；
｝
(3) 用指针变量指向数组元素。
#include <stdio.h>
void main（）
｛ int ａ［１０］；
int *ｐ，ｉ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（ ″％ｄ ″，＆ａ［ｉ］）；
printf（ ″＼ｎ ″）；
for（ｐ＝ａ；ｐ＜（ａ＋１０）；ｐ＋＋）
printf（ ″％ｄ ″,*ｐ）；
｝
例 10.６ 通过指针变量输出ａ数组的１０个元素。
有人编写出以下程序：
#include <stdio.h>
void main（）
｛ int *ｐ，ｉ，ａ［１０］；
ｐ＝ａ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋ ）
scanf（ ″％ｄ ″，ｐ＋＋）；
printf（ ″＼ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋ ）
printf（ ″％ｄ ″,*ｐ）；
｝
这个程序乍看起来好像没有什么问题。有的人即使已被告知此程序有问题，还是找不出它有什么问题。我们先看一下运行情况：
1 2 3 4 5 6 7 8 9 0↙
22153 234 0 0 30036 25202 11631 8259 8237 28483
显然输出的数值并不是ａ数组中各元素的值解决这个问题的办法，只要在第二个ｆｏｒ循环之前加一个赋值语句：
ｐ＝ａ；
#include <stdio.h>
void main（）
｛ int *ｐ，ｉ，ａ［１０］；
ｐ＝ａ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（ ″％ｄ ″，ｐ＋＋）；
printg（ ″＼ｎ ″）；
p=a;
for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋ ）
printf（ ″％ｄ ″,*ｐ）；
｝
10.３,3 用数组名作函数参数在第 8章 8.7节中介绍过可以用数组名作函数的参数如,void main（）
{iｆ（ int ａｒｒ [],int ｎ） ;
int ａｒｒａｙ［１０］；
┇
ｆ（ａｒｒａｙ，１０）；
┇
｝
void ｆ (int ａｒｒ［ ］,int ｎ )
{
┇
}
f (int arr［ ］,int n)
但在编译时是将 arr按指针变量处理的，相当于将函数 f的首部写成
f (int *arr,int n)
以上两种写法是等价的。
需要说明的是,C语言调用函数时虚实结合的方法都是采用,值传递,方式,当用变量名作为函数参数时传递的是变量的值,当用数组名作为函数参数时,由于数组名代表的是数组首元素地址,因此传递的值是地址,所以要求形参为指针变量 。
例 10．７ 将数组ａ中ｎ个整数按相反顺序存放
#include <stdio.h>
void main（）
｛ void inv（ int ｘ［ ］,int ｎ） ;
int ｉ，ａ［１０］＝｛３，７，９，１１，０，
６，７，５，４，２｝；
printf（ ″The original array:＼ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf （ ″％ｄ,″，ａ［ｉ］）；
printf（ ″＼ｎ ″）；
inv （ａ，１０）；
printf（ ″The array has been in verted,\ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf （ ″％ｄ,″，ａ［ｉ］）；
printf （ ″＼ｎ ″）；
｝
void inv（ int ｘ［ ］,int ｎ） /*形参 x是数组名 */
｛ int temp，ｉ，ｊ，ｍ＝（ｎ－１）／２；
for（ｉ＝０；ｉ＜＝ｍ；ｉ＋＋）
｛
ｊ＝ｎ－１－ｉ；
temp＝ｘ［ｉ］；
ｘ［ｉ］＝ｘ［ｊ］；
ｘ［ｊ］＝ temp；
｝
return；
｝
运行情况如下：
The original array：
３，７，９，１１，０，６，７，５，４，２，
The array has been inverted：
２，４，５，７，６，０，１１，９，７，３，
#include <stdio.h>
void main（）
｛ void inv（ int *ｘ,int ｎ） ;
int ｉ，ａ［１０］＝｛３，７，９，１１，０，
６，７，５，４，２｝；
printf（ ″The original array:＼ｎ ″ ）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf （ ″％ｄ,″，ａ［ｉ］）；
printf （ ″＼ｎ ″）；
inv（ａ，１０）；
printf （ ″The array has been in verted,\ｎ ″ ）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf （ ″％ｄ,″，ａ［ｉ］）；
printf （ ″＼ｎ ″）； ｝
对这个程序可以作一些改动。将函数 inv中的形参ｘ改成指针变量。
void inv（ int *ｘ,int ｎ） /*形参 x为指针变量 */
｛ int ｐ,temp,*ｉ,*ｊ，ｍ＝（ｎ－１）／２；
ｉ＝ｘ；ｊ＝ｘ＋ｎ－１；ｐ＝ｘ＋ｍ；
for（；ｉ＜＝ｐ；ｉ＋＋，ｊ－－）
｛ｔ emp＝ *ｉ； *ｉ＝ *ｊ； *ｊ＝ temp；｝
return；
｝
归纳起来，如果有一个实参数组，想在函数中改变此数组中的元素的值，实参与形参的对应关系有以下４种情况：
(1) 形参和实参都用数组名，如：
void main（） void ｆ （ int ｘ [ ］,int ｎ）
｛ int ａ［１０］； {
… …
ｆ （ａ，１０）； }
｝
(2) 实参用数组名，形参用指针变量。如：
void ｍａｉｎ（） void ｆ （ int *ｘ,int ｎ）
｛ int ａ［１０］； {
… …
ｆ （ａ，１０）； }
｝
(3)实参形参都用指针变量。例如：
void main（） void ｆ（ int *ｘ,int ｎ）
｛ int ａ［１０］,*p=a; {
┇ ┇
ｆ（ p，１０）； }
｝
(4) 实参为指针变量，形参为数组名。如：
void main（） void ｆ（ int x[ ],int ｎ）
｛ｉｎｔ ａ［１０］,*p=a； {
┇ ┇
ｆ（ p，１０）； }
｝
#include <stdio.h>
void main（）
{ void inv（ int *ｘ,int ｎ） ;
int ｉ，ａｒｒ［１０］,*ｐ＝ａｒｒ；
printf（ ″The original array:\n ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋）
scanf（ ″％ｄ ″，ｐ）；
printf（ ″＼ｎ ″）；
ｐ＝ａｒｒ；
inv（ｐ，１０）； /* 实参为指针变量 */
printf（ ″The array has been inverted,＼ｎ ″）；
for（ｐ＝ａｒｒ；ｐ＜ａｒｒ＋１０；ｐ＋＋ ）
printf（ ″％ｄ ″,*ｐ）；
printf（ ″＼ｎ ″）；
｝
void inv（ int *ｘ,int ｎ）
｛ int ｐ，ｍ,temp,*ｉ,*ｊ；
ｍ＝（ｎ－１）／２；
ｉ＝ｘ；ｊ＝ｘ＋ｎ－１；ｐ＝ｘ＋ｍ；
for（；ｉ＜＝ｐ；ｉ＋＋，ｊ－－）
｛ｔ emp＝ *ｉ； *ｉ＝ *ｊ； *ｊ＝ temp；｝
return；
｝
例 10,9 用选择法对１０个整数按由大到小顺序排序
#include <stdio.h>
void main（）
{ void sort（ int ｘ［ ］,int ｎ） ;
int *ｐ，ｉ，ａ［ 10］；
ｐ＝ａ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（ ″％ｄ ″，ｐ＋＋）；
ｐ＝ａ；
sort（ｐ，１０）；
for（ｐ＝ａ，ｉ＝０；ｉ＜１０；ｉ＋＋）
｛ｐｒｉｎｔｆ（ ″％ｄ ″,*ｐ）；ｐ＋＋；｝
｝
void sort（ int ｘ [ ],int ｎ）
｛ int ｉ，ｊ，ｋ，ｔ；
for（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋）
｛ｋ＝ｉ；
for（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋）
ｉｆ（ｘ［ｊ］＞ｘ［ｋ］）
ｋ＝ｊ；
ｉｆ（ｋ！＝ｉ）
｛ｔ＝ｘ［ｉ］；
ｘ［ｉ］＝ｘ［ｋ］；
ｘ［ｋ］＝ｔ；｝
｝
｝
10.３,４ 多维数组与指针用指针变量可以指向一维数组中的元素，也可以指向多维数组中的元素。但在概念上和使用上，多维数组的指针比一维数组的指针要复杂一些。
1,多维数组元素的地址先回顾一下多维数组的性质,可以认为二维数组是“数组的数组”，例,
定义 int a［ 3］［ 4］ ={{1,3,5,7}，｛９，１１，
１３，１５｝，｛１７，１９，２１，２３｝ }；
则二维数组 a是由 3个一维数组所组成的。设二维数组的首行的首地址为２０００,则表 示 形 式 含义 地 址
a 二维数组名，指向一维数组
a[0］，即 0行首地址
2000
a[0］,
*(a+0),
*a
0行 0列元素地址 2000
a+1,&a［ 1］ 1行首地址 2008
a［ 1］,*(a+1) 1行 0列元素 a[1][0]的地址 2008
A[1]+2,
*(a+1)+2,
&a[1][2]
1行 2列元素 a[1][2] 的地址 2012
*(a[1]+2),
*(*(a+1)+2),
a[1][2]
1行 2列元素 a［ 1］［ 2］的值 元素值为 13
例 10.１ 0 输出二维数组有关的值
#include <stdio.h>
＃ define FROMAT ″％ｄ，％ｄ＼ｎ ″
void main（）
｛ int ａ [3][4]＝｛ 1,3,5,7,9，１１，１３，
１５，１７，１９，２１，２３｝；
printf（ＦＯＲＭＡＴ，ａ,*ａ）；
printf（ＦＯＲＭＡＴ，ａ [0],*（ａ＋０））；
printf（ＦＯＲＭＡＴ，＆ａ [0]，＆ａ [0][0]）；
printf（ＦＯＲＭＡＴ，ａ [1]，ａ＋１）；
printf（ＦＯＲＭＡＴ，＆ａ [1][0],*（ａ +１） +０）；
printf（ＦＯＲＭＡＴ，ａ［２］,*（ａ＋２））；
printf（ＦＯＲＭＡＴ，＆ａ［２］，ａ＋２）；
printf（ＦＯＲＭＡＴ，ａ［１］［０］,*（ *（ａ＋
１）＋０））；
｝
某一次运行结果如下：
１５８，１５８ (0行首地址和 0行 0列元素地址 )
１５８，１５８ (0行 0列元素地址 )
１５８，１５８ (0行 0首地址和 0行 0列元素地址 )
１６６，１６６ (1行 0列元素地址和 1行首地址 )
１６６，１６６ (1行 0列元素地址 )
１７４，１７４ (2行 0列元素地址 )
１７４，１７４ (2行首地址 )
９，９ (1行 0列元素的值 )
2,指向多维数组元素的指针变量在了解上面的概念后，可以用指针变量指向多维数组的元素。
(1) 指向数组元素的指针变量例 10.11 用指针变量输出二维数组元素的值
#include <stdio.h>
void main（）
｛ int ａ [3][4]＝｛ 1,3,5,7,9,11,13,15,17,19,21,23｝；
int *ｐ；
for（ｐ＝ａ［０］；ｐ＜ａ［０］＋１２；ｐ＋＋）
｛ｉｆ（（ｐ－ａ［０］）％４＝＝０）
printf（ ″＼ｎ ″）；
printf（ ″％４ｄ ″,*ｐ）； ｝
｝
运行结果如下：
1 3 5 7
9 11 13 15
19 21 23
可将程序最后两个语句改为
printf（ ″addr＝％ｏ,value＝％ 2ｄ＼ｎ ″,ｐ,*ｐ）；
在 TC++环境下某一次运行时输出如下：
ａｄｄｒ＝２３６，ｖａｌｕｅ＝１
ａｄｄｒ＝２４０，ｖａｌｕｅ＝３
ａｄｄｒ＝２４２，ｖａｌｕｅ＝５
ａｄｄｒ＝２４４，ｖａｌｕｅ＝７
ａｄｄｒ＝２４６，ｖａｌｕｅ＝９
ａｄｄｒ＝２５０，ｖａｌｕｅ＝１１
ａｄｄｒ＝２５２，ｖａｌｕｅ＝１３
ａｄｄｒ＝２５４，ｖａｌｕｅ＝１５
ａｄｄｒ＝２５６，ｖａｌｕｅ＝１７
ａｄｄｒ＝２６０，ｖａｌｕｅ＝１９
ａｄｄｒ＝２６２，ｖａｌｕｅ＝２１
ａｄｄｒ＝２６４，ｖａｌｕｅ＝２３
(2) 指向由ｍ个元素组成的一维数组的指针变量例 10.13 出二维数组任一行任一列元素的值
#include <stdio.h>
void main ( )
｛ int ａ［３］［４］＝｛ 1,3,5,7,9,11，
13,15，１７，１９，２１，２３｝；
int （ *ｐ）［４］，ｉ，ｊ；
ｐ＝ａ；
scanf（ ″ ｉ＝％ｄ，ｊ＝％ｄ ″，＆ｉ，＆ｊ）；
printf（ ″ａ［％ｄ，％ｄ］＝％ｄ＼ｎ ″，ｉ，
ｊ,*（ *（ｐ＋ｉ）＋ｊ））；
｝
运行情况如下：
ｉ＝１，ｊ＝２ ↙ （本行为键盘输入）
ａ［１，２］＝１３
运行情况如下：
ｉ＝１，ｊ＝２ ↙ （本行为键盘输入）
ａ［１，２］＝１３
3,用指向数组的指针作函数参数例 10.13 有一个班，３个学生，各学４门课，计算总平均分数以及第ｎ个学生的成绩。这个题目是很简单的。只是为了说明用指向数组的指针作函数参数而举的例子。用函数ａｖｅｒａｇｅ求总平均成绩，用函数ｓｅａｒｃｈ找出并输出第ｉ个学生的成绩。
#include <sydio.h>
void main（）
{ void average（ float *p,int n）；
void search（ float (*p）［ 4］,int n)；
float score［ 3］［ 4］ ={{65,67,70,60},{80，
87,90,81},{90,99,100,98}};
average（ *score,12）； ／ *求 12个分数的平均分 *／
search（ score，２）； ／ *求序号为２的学生的成绩 *／
｝
void average（ float *ｐ,int ｎ）
{ float *ｐ _ｅｎｄ；
float ｓｕｍ＝０，ａｖｅｒ；
ｐ _ｅｎｄ＝ｐ＋ｎ－１；
ｆｏｒ（；ｐ＜＝ｐ _ｅｎｄ；ｐ＋＋）
ｓｕｍ＝ｓｕｍ＋（ *ｐ）；
ａｖｅｒ＝ｓｕｍ／ｎ；
printf（ ″average＝％５．２ｆ＼ｎ ″,aver）；
｝
void search（ float (*ｐ )[4],int ｎ）
/ * p是指向具有 4个元素的一维数组的指针 */
｛ int ｉ；
printf（ ″the score of No,%ｄ are：＼ｎ ″，ｎ）；
for（ｉ＝０；ｉ＜４；ｉ＋＋ )
printf（ ″％ 5.2ｆ ″,*（ *（ｐ＋ｎ）＋ｉ））；
｝
程序运行结果如下：
ａｖｅｒａｇｅ＝８２．２５
ｔｈｅ ｓｃｏｒｅ ｏｆ Ｎｏ．２ ａｒｅ：
９０,００ ９９,００ １００,００ ９８,００
例 10.１ 4 在上题基础上，查找有一门以上课程不及格的学生，打印出他们的全部课程的成绩。
#include <stdio.h>
void main（）
｛ void search（ float (*p)［ 4］,int n）； /*函数声明 */
float score[3][4]={{65,57,70,60},{58,87，
90,81},{90,99,100,98}};
search（ score，３）；
｝
void search（ float (*p)［ 4］,int ｎ）
｛ int ｉ，ｊ，ｆｌａｇ；
for（ｊ＝０；ｊ＜ｎ；ｊ＋＋ )
｛ flag＝０；
for（ｉ＝０；ｉ＜４；ｉ＋＋ )
if（ *（ *（ｐ＋ｊ）＋ｉ）＜６０ ) flag＝１；
if（ｆｌａｇ＝＝１）
{ printf("No.%d fails,his scores are:＼ n",j+1);
for（ｉ＝０；ｉ＜４；ｉ＋＋）
printf（ ″%５,１ｆ ″,*(*(ｐ＋ｊ )＋ｉ ))；
printf（ ″＼ｎ ″）；
｝
｝
｝
程序运行结果如下：
Ｎｏ．１ ｆａｉｌ s，ｈｉｓ ｓｃｏｒｅｓ ａｒｅ：
６５,０ ５７,０ ７０,０ ６０,０
Ｎｏ．２ ｆａｉｌ s，ｈｉｓ ｓｃｏｒｅｓ ａｒｅ ∶
５８,０ ８７,０ ９０,０ ８１,０
§ 10.４ 字符串与指针
10．４．１字符串的表示形式例 10.１ 5 定义一个字符数组，对它初始化，
然后输出该字符串
#include <stdio.h>
void main（）
｛ char string［］＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
printf（ ″％ｓ＼ｎ ″，ｓｔｒｉｎｇ）；
｝
(1) 用字符数组存放一个字符串，然后输出该字符串。
(2) 用字符指针指向一个字符串可以不定义字符数组，而定义一个字符指针。用字符指针指向字符串中的字符。
例 10．１ 6 定义字符指针
#include <stdio.h>
void main（）
｛ char string＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
printf（ ″％ｓ＼ｎ ″，ｓｔｒｉｎｇ）；
｝
例 10.１ 7 将字符串ａ复制为字符串ｂ
对字符串中字符的存取，可以用下标方法，也可以用指针方法
#include <stdio.h>
void ｍａｉｎ（）
｛ char ａ [ ]＝ ″Ｉ am a boy,″，ｂ [20]；
int ｉ；
for（ｉ＝０； *（ａ＋ｉ）！＝ ′＼０ ′；ｉ＋＋）
*（ｂ＋ｉ）＝ *（ａ＋ｉ）；
*（ｂ＋ｉ）＝ ′＼０ ′；
printf（ ″string a is,％ｓ＼ｎ ″，ａ）；
printf（ ″ｓｔｒｉｎｇ ｂ ｉｓ,″）；
for（ｉ＝０；ｂ［ｉ］！＝ ′＼０ ′；ｉ＋＋）
printf（ ″％ｃ ″，ｂ［ｉ］）；
printf（ ″＼ｎ ″）；
｝
也可以设指针变量，用它的值的改变来指向字符串中的不同的字符。
例 10.１ 8 用指针变量来处理例 10．１ 7问题。
#include <stdio.h>
void main（）
｛ char ａ [ ] =″I am a boy,″，ｂ [20],*p1,*p2；
int ｉ；
ｐ１＝ａ；ｐ２＝ｂ；
for（； *ｐ１！＝ ′＼０ ′； p1＋＋,p2＋＋）
*ｐ２＝ *ｐ１；
*ｐ２＝ ′＼０ ′；
printf（ ″string ａ is：％ｓ＼ｎ ″，ａ）；
printf（ ″ｓｔｒｉｎｇ ｂ ｉｓ,″）；
for（ｉ＝０；ｂ［ｉ］！＝ ′＼０ ′；ｉ＋＋）
printf（ ″％ｃ ″，ｂ［ｉ］）；
printf（ ″＼ｎ ″）；
｝
程序必须保证使ｐ１和ｐ２同步移动。
10.４,２ 字符指针作函数参数例 10,19 用函数调用实现字符串的复制
#include <stdio.h>
void main（）
{ void copy_string（ char from［ ］,char to［ ］） ;
char a[ ]=″Ｉ am a teacher,″；
char ｂ [ ]=″you are a student,″；
printf(“string a=％ｓ＼ｎ string ｂ＝％ｓ＼ｎ ″，
ａ，ｂ )；
printf("copy string a to string b:\n ");
copy_string （ａ，ｂ）；
printf("＼ nstring a=%s＼ nstring b=%s＼ n",a,b);
｝
(1) 用字符数组作参数
void copy_string（ char from［ ］,char to［ ］）
｛ int ｉ＝０；
while（ｆｒｏｍ［ｉ］！＝ ′＼０ ′）
｛ｔｏ［ｉ］＝ｆｒｏｍ［ｉ］；ｉ＋＋；｝
ｔｏ［ｉ］＝ ′＼０ ′；
｝
程序运行结果如下：
ｓｔｒｉｎｇ ａ＝Ｉ ａｍ ａ ｔｅａｃｈｅｒ．
ｓｔｒｉｎｇ ｂ＝ｙｏｕ ａｒｅ ａ ｓｔｕｄｅｎｔ．
copy string a to string b:
ｓｔｒｉｎｇ ａ＝Ｉ ａｍ ａ ｔｅａｃｈｅｒ．
ｓｔｒｉｎｇ ｂ＝Ｉ ａｍ ａ ｔｅａｃｈｅｒ．
（２） 形参用字符指针变量
#include <stdio.h>
void main（）
{ void copy_string（ char *ｆｒｏｍ,char *ｔｏ） ;
char *ａ＝ ″Ｉ am a teacher,″；
char *ｂ＝ ″you are a student,″；
printf("string a=％ｓ＼ｎｓｔｒｉｎｇ ｂ＝％
ｓ＼ｎ ″，ａ，ｂ )；
printf("copy string a to string b:\n ");
ｃｏｐｙ _ｓｔｒｉｎｇ（ａ，ｂ）；
printf("＼ nstring a=%s＼ nstring b=%s＼ n",a，
b);
｝
void copy_string（ char *ｆｒｏｍ,char *ｔｏ）
｛ for（； *from！＝ ′＼０ ′； from＋＋,to＋＋）
*
*ｔｏ＝ ′＼０ ′；
｝
（３） 对 copy_string 函数还可作简化
1、将 copy_string函数改写为
void copy_string （ char *ｆｒｏｍ,char *ｔｏ）
｛ while（（ *ｔｏ＝ *ｆｒｏｍ）！＝ ′＼０ ′）
｛ｔｏ＋＋；ｆｒｏｍ＋＋；｝
｝
2,copy_string函数的函数体还可改为
｛
while（（ *to＋＋＝ *from＋＋）！＝ ′＼０ ′）；
｝
3,copy_string函数的函数体还可写成
{
while（ *ｆｒｏｍ！＝ ′＼０ ′）
*ｔｏ＋＋＝ *ｆｒｏｍ＋＋；
*ｔｏ＝ ′＼０ ′；
｝
4、上面的 while语句还可以进一步简化为下面的 while
语句：
while（ *ｔｏ＋＋＝ *ｆｒｏｍ＋＋）；
它与下面语句等价：
while（（ *to＋＋＝ *from＋＋）！＝ ′＼０ ′）；
将 *ｆｒｏｍ赋给 *ｔｏ，如果赋值后的 *ｔｏ值等于 ′
＼０ ′，则循环终止（ ′＼０ ′已赋给 *ｔｏ）
5、函数体中ｗｈｉｌｅ语句也可以改用ｆｏｒ语句：
for（；（ *to＋＋＝ *from＋＋）！＝０；）；
或
for（； *to＋＋＝ *from＋＋；）；
6、也可用指针变量，函数 copy_string可写为
void copy_string （ char from［ ］,char ｔｏ［ ］）
*ｐ１,*ｐ２；
ｐ１＝ｆｒｏｍ；ｐ２＝ｔｏ；
while（（ *p2＋＋＝ *p1＋＋）！＝ ′＼０ ′）；
｝
10.４,３ 对使用字符指针变量和字符数组的讨论虽然用字符数组和字符指针变量都能实现字符串的存储和运算，但它们二者之间是有区别的，不应混为一谈，主要有以下几点：
(1) 字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的是地址（字符串第 1
个字符的地址），决不是将字符串放到字符指针变量中。
(2)赋值方式。对字符数组只能对各个元素赋值，不能用以下办法对字符数组赋值。
char str［１４］；
str＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
而对字符指针变量，可以采用下面方法赋值：
char *ａ；
ａ＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
但注意赋给ａ的不是字符，而是字符串第一个元素的地址。
(3)对字符指针变量赋初值：
char *ａ＝ ″Ｉ love China！ ″；等价于
char *ａ；
ａ＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
而对数组的初始化：
char str［１４］＝｛ ″Ｉ love China！ ″｝ ;
不能等价于
char str［１４］；
str［ ］＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
(4) 如果定义了一个字符数组，在编译时为它分配内存单元，它有确定的地址。而定义一个字符指针变量时，给指针变量分配内存单元，在其中可以放一个字符变量的地址也就是说，该指针变量可以指向一个字符型数据，但如果未对它赋予一个地址值，
则它并未具体指向一个确定的字符数据。
如,char str［１０］；
scanf（ ″％ｓ ″,str）； 是可以的。
而常有人用下面的方法,目的是想输入一个字符串，虽然一般也能运行，但这种方法是危险的,
char *ａ；
scanf（ ″％ｓ ″，ａ）；
应当这样：
*ａ，ｓｔｒ［１０］；
ａ＝ｓｔｒ；
ｓｃａｎｆ（ ″％ｓ ″，ａ）；
(5) 指针变量的值是可以改变的，如：
例 10.２ 0 改变指针变量的值
#include <stdio.h>
void ｍａｉｎ（）
｛ char *ａ＝ ″I love China！ ″；
ａ＝ａ＋７；
printf（ ″％ｓ ″，ａ）；
｝
需要说明，若定义了一个指针变量，并使它指向一个字符串，就可以用下标形式引用指针变量所指的字符串中的字符。例 10．２ 1
#include <stdio.h>
void main（）
｛ char *ａ＝ ″Ｉ love Ｃ hina!″；
int ｉ；
printf (,The sixth character is %c＼ n",a［ 5］ );
for（ｉ＝０；ａ［ｉ］！＝ ′＼０ ′；ｉ＋＋）
printf（ ″％ｃ ″，ａ［ｉ］）；
｝
10.５ 指向函数的指针
10.５,１ 用函数指针变量调用函数可以用指针变量指向整型变量、字符串、数组，
也可以指向一个函数。一个函数在编译时被分配给一个入口地址。这个 函数的入口地址就称为函数的指针 。
例 10.２ 2 求ａ和ｂ中的大者。先列出按一般方法的程序。
#include <stdio.h>
void main（）
｛ int max（ int,int）；
int ａ，ｂ，ｃ；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
ｃ＝ｍａｘ（ａ，ｂ）；
printf（ ″ａ＝％ｄ，ｂ＝％ｄ，ｍａｘ＝％ｄ
″，ａ，ｂ，ｃ）；
｝
int max（ int ｘ,int ｙ）
｛ int ｚ；
if（ｘ＞ｙ）ｚ＝ｘ；
else ｚ＝ｙ；
return（ｚ）；
｝
将 main 函数改写为
#include <stdio.h>
void main（）
｛ int ｍａｘ（ int,int）；
int （ *ｐ）（）；
int ａ，ｂ，ｃ；
ｐ＝ｍａｘ；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
ｃ＝（ *ｐ）（ａ，ｂ）；
printf（ ″ａ＝％ｄ，ｂ＝％ｄ，ｍａｘ＝％
ｄ ″，ａ，ｂ，ｃ）；
｝
10.５,２ 用指向函数的指针作函数参数函数指针变量常用的用途之一是把指针作为参数传递到其他函数。前面介绍过，函数的参数可以是变量、
指向变量的指针变量、数组名、指向数组的指针变量等。现在介绍指向函数的指针也可以作为参数，以实现函数地址的传递，这样就能够在被调用的函数中使用实参函数。它的原理可以简述如下：有一个函数
（假设函数名为 sub），它有两个形参（ x1和 x2），
定义 x1和 x2为指向函数的指针变量。在调用函数 sub
时，实参为两个函数名ｆ１和ｆ２，给形参传递的是函数ｆ１和ｆ２的地址。这样在函数ｓｕｂ中就可以调用ｆ１和ｆ２函数了。
实参函数名 f1 ｆ２
↓ ↓
void ｓｕｂ（ int (*x1)(int),int (*x2)(int,int)）
｛ int ａ，ｂ，ｉ，ｊ；
ａ＝（ *ｘ１）（ｉ）； ／ *调用ｆ１函数 *／
ｂ＝（ *ｘ２）（ｉ，ｊ）； ／ *调用ｆ２函数 *／
…
｝
例 10.２ 3 设一个函数 process，在调用它的时候，每次实现不同的功能。输入ａ和ｂ两个数，第一次调用
process时找出ａ和ｂ中大者，第二次找出其中小者，
第三次求ａ与ｂ之和。
#include <stdio.h>
void main（）
｛ int max（ int,int） ; /* 函数声明 */
int min（ int,int） ; /* 函数声明 */
int add（ int,int）； /* 函数声明 */
void process (int,int,int(*fun)(); /* 函数声明 */
int ａ，ｂ；
printf（ ″ｅｎｔｅｒ ａ ａｎｄ ｂ,″）；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
ｐｒｉｎｔｆ（ ″ｍａｘ＝ ″）；
ｐｒｏｃｅｓｓ（ａ，ｂ，ｍａｘ）；
ｐｒｉｎｔｆ（ ″ｍｉｎ＝ ″）；
ｐｒｏｃｅｓｓ（ａ，ｂ，ｍｉｎ）；
ｐｒｉｎｔｆ（ ″ｓｕｍ＝ ″）；
ｐｒｏｃｅｓｓ（ａ，ｂ，ａｄｄ）；
｝
int ｍａｘ（ int ｘ,int ｙ） /* 函数定义 */
｛ｉｎｔ ｚ；
ｉｆ（ｘ＞ｙ）ｚ＝ｘ；
ｅｌｓｅ ｚ＝ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
int ｍｉｎ（ int ｘ,int ｙ） /* 函数定义 */
｛ｉｎｔ ｚ；
ｉｆ（ｘ＜ｙ）ｚ＝ｘ；
ｅｌｓｅ ｚ＝ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
int ａｄｄ（ int ｘ,int ｙ） /* 函数定义 */
｛ｉｎｔ ｚ；
ｚ＝ｘ＋ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
void process(int ｘ,int ｙ,int (*fun)(int,int))
｛ｉｎｔ ｒｅｓｕｌｔ；
ｒｅｓｕｌｔ＝（ *ｆｕｎ）（ｘ，ｙ）；
ｐｒｉｎｔｆ（ ″％ｄ＼ｎ ″，ｒｅｓｕｌｔ）；
｝
10.６ 返回指针值的函数一个函数可以带回一个整型值、字符值、实型值等，
也可以带回指针型的数据，即地址。其概念与以前类似，只是带回的值的类型是指针类型而已。
这种带回指针值的函数，一般定义形式为类型名 *函数名（参数表列） ;
例如：
ｉｎｔ *ａ（ int ｘ,int ｙ） ;
例 10．２ 4 有若干个学生的成绩（每个学生有４门课程），要求在用户输入学生序号以后，能输出该学生的全部成绩。用指针函数来实现。
#include <stdio.h>
void main（）
｛ float *score［ ］［ 4］ ={{60,70,80,90}，
{56,89,67,88},{34,78,90,66}};
float *search（ float (*pointer)［ 4］,int n）；
float *ｐ；
int ｉ，ｍ；
printf（ ″enter the number of student,″）；
scanf（ ″％ｄ ″，＆ｍ）；
printf（ ″The scores of No．％ｄ are,\ｎ ″，ｍ）；
ｐ＝ search（ｓｃｏｒｅ，ｍ）；
for（ｉ＝０；ｉ＜４；ｉ＋＋＝
printf（ ″％５．２ｆ＼ｔ ″,*（ｐ＋ｉ））；
｝
float * search（ float (*ｐｏｉｎｔｅｒ )［ 4］,int ｎ）
｛ float *ｐｔ；
ｐｔ＝ *（ｐｏｉｎｔｅｒ＋ｎ）；
return（ｐｔ）；
｝
运行情况如下：
enter the number of student,１ ↙
The scores of No,１ are：
56.00 89.00 67.00 88.00
例 10．２ 5 对上例中的学生，找出其中有不及格课程的学生及其学生号。
#include <stdio.h>
void main（）
{float score［ ］［ 4］ ={{60,70,80,90},{56，
89,67,88},{34,78,90,66}};
float search（ float (*pointer)［ 4］）；
float *ｐ；
iｎｔ ｉ，ｊ；
fｏｒ（ｉ＝０；ｉ＜３；ｉ＋＋）
｛ｐ＝ｓｅａｒｃｈ（ｓｃｏｒｅ＋ｉ）；
ｉｆ（ｐ＝＝ *（ｓｃｏｒｅ＋ｉ））
｛ printf（ ″Ｎｏ．％ｄ scores,″，ｉ）；
for（ｊ＝０；ｊ＜４；ｊ＋＋ )
printf（ ″％５．２ｆ ″,*（ｐ＋ｊ））；
printf（ ″＼ｎ ″）；｝
｝
｝
10.７指针数组和指向指针的指针
10.７,１ 指针数组的概念一个数组，若其元素均为指针类型数据，称为 指针数组,也就是说，指针数组中的每一个元素都相当于一个指针变量。一维指针数组的定义形式为例如：
*ｐ [４ ]；
例 10．２ 6 将若干字符串按字母顺序（由小到大）输出。
#include <stdio.h>
#include <string.h>
void main（）
｛ void sort（ char *name［ ］,int n）；
void printf（ char *name［ ］,int n）；
char *name［ ］ ={"Follow me","BASIC","Great
Wall″,"FORTRAN","Computer design"};
int ｎ＝５；
sort（ｎａｍｅ，ｎ）；
print（ｎａｍｅ，ｎ）；
｝
void sort（ char *ｎａｍｅ［ ］,int ｎ）
｛ char *ｔｅｍｐ；
int ｉ，ｊ，ｋ；
for（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋＝
｛ｋ＝ｉ；
for（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋＝
if（ strcmp（ name[ｋ ],name[ｊ ]） >0）ｋ =ｊ；
if（ｋ !＝ｉ）
temp=name［ i］ ;
name［ i］ =name［ k］ ;
name［ k］ =temp;｝
｝
｝
void print（ char *ｎａｍｅ［ ］,int ｎ）
｛ｉｎｔ ｉ；
ｆｏｒ（ｉ＝０；ｉ＜ｎ；ｉ＋＋）
printf（ ″％ｓ＼ｎ ″，ｎａｍｅ［ｉ］）；
}
运行结果为：
ＢＡＳＩＣ
Ｃｏｍｐｕｔｅｒ ｄｅｓｉｇｎ
ＦＯＲＴＲＡＮ
Ｆｏｌｌｏｗ ｍｅ
Ｇｒｅａｔ Ｗａｌｌ
10．７．２ 指向指针的指针怎样定义一个指向指针数据的指针变量呢？ 如下：
**ｐ；
ｐ的前面有两个 *号。 *运算符的结合性是从右到左，
因此 **ｐ相当于 *（ *ｐ），显然 *ｐ是指针变量的定义形式。如果没有最前面的 *，那就是定义了一个指向字符数据的指针变量。现在它前面又有一个
*号，表示指针变量ｐ是指向一个字符指针变量的。
*ｐ就是ｐ所指向的另一个指针变量。
例 10．２ 7 使用指向指针的指针
#include <stdio.h>
void main（）
｛ char *name［］ ={"Follow me","BASIC","Great
Wall″,"FORTRAN","Computer design"};
char **ｐ；
int ｉ；
for（ｉ＝０；ｉ＜５；ｉ＋＋）
｛ｐ＝ｎａｍｅ＋ｉ；
printf（ ″％ｓ＼ｎ ″,*ｐ）；
｝
｝
例 10.28 一个指针数组的元素指向整型数据的简单例子
#include <stdio.h>
void main（）
｛ int ａ［５］＝｛１，３，５，７，９｝；
int *num［ 5］ =｛ &a［ 0］,&a［ 1］，
&a［ 2］,&a［ 3］,&a［ 4］｝；
int **ｐ，ｉ；
ｐ＝ｎｕｍ；
for（ｉ＝０；ｉ＜５；ｉ＋＋＝
｛ printf（ ″％ｄ ″,**ｐ）；
ｐ＋＋；
｝
｝
10.７,３ 指针数组作ｍａｉｎ函数的形参指针数组的一个重要应用是作为 main函数的形参。在以往的程序中，ｍａｉｎ函数的第一行一般写成以下形式,void main（）
括弧中是空的。实际上,main函数可以有参数，例如：
void main（ int argc,char *argv[ ]）
argc和 argv就是 main函数的形参。 main函数是由操作系统调用的。那么,main函数的形参的值从何处得到呢？
显然不可能在程序中得到。实际上实参是和命令一起给出的。也就是在一个命令行中包括命令名和需要传给 main函数的参数。命令行的一般形式为 命令名 参数
１ 参数２ …… 参数ｎ
如果有一个名为ｆｉｌｅ１的文件，它包含以下的ｍ
ａｉｎ函数,
void main（ int ａｒｇｃ,char *ａｒｇｖ［ ］）
｛ｗｈｉｌｅ（ａｒｇｃ＞１）
｛＋＋ａｒｇｖ；
ｐｒｉｎｔｆ（ ″％ｓ＼ｎ ″
－－ａｒｇｃ；
｝
｝
在 DOS命令状态下输入的命令行为
ｆｉｌｅ１ Ｃｈｉｎａ Ｂｅｉｊｉｎｇ
则执行以上命令行将会输出以下信息：
Ｃｈｉｎａ
Ｂｅｉｊｉｎｇ
10.８有关指针的数据类型和指针运算的小结
10.8.1有关指针的数据类型的小结定义 含义
ｉｎｔ ｉ； 定义整型变量ｉ
*ｐ； ｐ为指向整型数据的指针变量
int a［ n］ ; 定义整型数组ａ，它有ｎ个元素
ｉｎｔ *ｐ［ｎ］； 定义指针数组ｐ，它由ｎ个指向整型数据的指针元素组成
ｉｎｔ （ *ｐ）［ｎ］； ｐ为指向含ｎ个元素的一维数组的指针变量
ｉｎｔ ｆ（）； ｆ为带回整型函数值的函数
ｉｎｔ *ｐ（）； ｐ为带回一个指针的函数，该指针指向整型数据
ｉｎｔ （ *ｐ）（）； ｐ为指向函数的指针，该函数返回一个整型值
ｉｎｔ **ｐ； ｐ是一个指针变量，它指向一个指向整型数据的指针变量
10.8.2 指针运算小结
(1) 指针变量加（减）一个整数例如：ｐ＋＋、ｐ－－、ｐ＋ｉ、ｐ－ｉ、ｐ＋＝ｉ、
ｐ－＝ｉ等。
(2) 指针变量赋值将一个变量地址赋给一个指针变量。如：
ｐ＝＆ａ； （将变量ａ的地址赋给ｐ）
ｐ＝ array； （将数组ａｒｒａｙ首元素地址赋给ｐ）
ｐ＝＆ array［ｉ］；（将数组ａｒｒａｙ第ｉ个元素的地址赋给ｐ）
ｐ＝ max；（ｍａｘ为已定义的函数，将ｍａｘ的入口地址赋给ｐ）
ｐ１＝ｐ２；（ｐ１和ｐ２都是指针变量，将ｐ２的值赋给ｐ１）
(3) 指针变量可以有空值，即该指针变量不指向任何变量,可以这样表示,ｐ＝ＮＵＬＬ ；
(4) 两个指针变量可以相减如果两个指针变量都指向同一个数组中的元素，则两个指针变量值之差是两个指针之间的元素个数
(5) 两个指针变量比较若两个指针指向同一个数组的元素，则可以进行比较。
指向前面的元素的指针变量“小于”指向后面元素的指针变量。
10.8.3 void指针类型
ANSIC新标准增加了一种,void”指针类型，即可定义一个指针变量，但不指定它是指向哪一种类型数据的。
ANSIC标准规定用动态存储分配函数时返回 void指针，
它可以用来指向一个抽象的类型的数据，在将它的值赋给另一指针变量时要进行强制类型转换使之适合于被赋值的变量的类型。例如,
*ｐ１；
*ｐ２；
…
ｐ１＝（ｃｈａｒ *）ｐ２；
同样可以用（ｖｏｉｄ *）ｐ１将ｐ１的值转换成
ｖｏｉｄ *类型。如：
ｐ２＝（ｖｏｉｄ *）ｐ１；
也可以将一个函数定义为ｖｏｉｄ *类型，如,
ｖｏｉｄ *ｆｕｎ（ char ch1,char ch2）
表示函数ｆｕｎ返回的是一个地址，它指向“空类型”，如需要引用此地址，也需要根据情况对之进行类型转换，如对该函数调用得到的地址要进行以下转换：
ｐ１＝（ｃｈａｒ *）ｆｕｎ（ｃ h１，ｃ h２）；
§ 10.1地址和指针的概念为了说清楚什么是指针，必须弄清楚数据在内存中是如何存储的，又是如何读取的。
内存区的每一个字节有一个编号，这就是,地址,。
如果在程序中定义了一个变量，在对程序进行编译时，
系统就会给这个变量分配内存单元。
１、按变量地址存取变量值的方式称为,直接访问,方式
ｐｒｉｎｔｆ（ ″％ｄ ″，ｉ） ;
ｓｃａｎｆ（ ″％ｄ ″，＆ｉ）；
ｋ＝ｉ＋ｊ；
例如：
另一种存取变量值的方式称为,间接访问,的方式。
即，将变量ｉ的地址存放在另一个变量中。
在Ｃ语言中，指针是一种特殊的变量，它是存放地址的。
假设我们定义了一个指针变量 i_pointer用来存放整型变量的地址，它被分配地址为 (3010),(3011)的两个字节。
可以通过语句,i_pointer ＝＆ｉ；
将ｉ的地址 (2000)存放到 i_pointer中。这时,i_pointer
的值就是 (2000),即变量ｉ所占用单元的起始地址。要存取变量ｉ的值，可以采用间接方式：先找到存放“ｉ
的地址”的变量 i_pointer,从中取出ｉ的地址 (2000)，
然后到 2000,200１字节取出ｉ的值（３）。
一个变量的地址称为该变量的,指针,。
例如，地址 2000是变量ｉ的指针。 如果有一个变量专门用来存放另一变量的地址（即指针），则它称为
,指针变量,。上述的 i_pointer就是一个指针变量。
指针和指针变量的定义：
指针变量的值（即指针变量中存放的值）是地址（即指针）。请区分“指针”和“指针变量”
这两个概念。
§ 10.2 变量的指针和指向变量的指针变量
10.２,1 定义一个指针变量定义指针变量的一般形式为基类型 *指针变量名；
下面都是合法的定义：
float *pointer_３； // pointer_３是指向 float型变量的指针变量
char *pointer_４； //pointer_４是指向字符型变量的指针变量可以用赋值语句使一个指针变量得到另一个变量的地址，从而使它指向一个该变量。如：
pointer_１＝＆ｉ；
pointer_２＝＆ｊ；
在定义指针变量时要注意两点：
(1)指针变量前面的,*”,表示该变量的类型为指针型变量。
例,float *pointer_1；
指针变量名是 pointer_1,而不是 * pointer_1 。
(2) 在定义指针变量时必须指定基类型。
需要特别注意的是，只有整型变量的地址才能放到指向整型变量的指针变量中。下面的赋值是错误的 ∶
float a;
int * pointer_1;
pointer_1=&a; /* 将 float型变量的地址放到指向整型变量的指针变量中，错误 */
10.２,２ 指针变量的引用请牢记，指针变量中只能存放地址（指针），
不要将一个整数（或任何其他非地址类型的数据）
赋给一个指针变量。
例 10.１ 通过指针变量访问整型变量
#include <stdio.h>
void main ( )
｛ int ａ，ｂ；
int *pointer_１,*pointer_２；
ａ＝１００；ｂ＝１０；
pointer_１＝＆ａ； /*把变量ａ的地址赋给
pointer_1 */
pointer_２＝＆ｂ； /*把变量ｂ的地址赋给
pointer_２ */
printf（ ″%ｄ,%ｄ \ｎ ″,ａ,ｂ）；
printf（ ″%ｄ,%ｄ \ｎ ″,*pointer_１,*pointer_２）；
｝
对“＆”和,*”运算符说明：
如果已执行了语句 pointer_１＝＆ａ；
(1)＆ * pointer_１ 的含义是什么？“＆”和,*”两个运算符的优先级别相同，但按自右而左方向结合，
因此先进行 * pointer_１ 的运算，它就是变量ａ，再执行＆运算。因此,＆ * pointer_１ 与 ＆ａ 相同，即变量 a的地址。如果有 pointer_2 ＝＆ * pointer_１ ；
它的作用是将＆ａ（ａ的地址）赋给 pointer_2,如果 pointer_2原来指向ｂ，经过重新赋值后它已不再指向ｂ了，而指向了ａ。
(2) *＆ａ的含义是什么？先进行＆ａ运算，得ａ的地址，再进行 *运算。即＆ａ所指向的变量，也就是变量
a。 *＆ａ和 *pointer_１的作用是一样的，它们都等价于变量ａ。即 *＆ａ与ａ等价。
(3) （ *pointer_１）＋＋相当于ａ＋＋。注意括号是必要的，如果没有括号，就成为了 *pointer_１＋＋，从附录可知,++和 *为同一优先级别，而结合方向为自右而左，因此它相当于 *(pointer_１＋＋ )。由于 ++在
pointer_1的右侧，是“后加”，因此先对 pointer_１的原值进行 *运算，得到ａ的值，然后使 pointer_１的值改变，这样 pointer_１不再指向ａ了。
例 10,2 输入ａ和ｂ两个整数，按先大后小的顺序输出
ａ和ｂ。
#include <stdio.h>
void main（）
｛ int *ｐ 1,*ｐ 2,*ｐ，ａ，ｂ；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
ｐ 1＝＆ａ；ｐ２＝＆ｂ；
if（ａ＜ｂ）
｛ｐ＝ｐ１；ｐ１＝ｐ２；ｐ２＝ｐ；｝
printf（ ″ａ =％ｄ,ｂ =％ｄ \ｎ \ｎ ″,ａ,ｂ）；
printf（ ″max=％ｄ,min=％ｄ \ｎ ″,*ｐ 1,*ｐ 2）；
｝
运行情况如下：
５，９ ↙
ａ＝５，ｂ＝９
ｍａｘ＝９，ｍｉｎ＝５
当输入ａ＝５，ｂ＝９时，由于ａ＜ｂ，
将ｐ１和ｐ２交换。交换前的情况见图
（ａ），交换后见图（ｂ）。
10.２,3 指针变量作为函数参数例 10,3 对输入的两个整数按大小顺序输出
#include <stdio.h>
void main（）
｛ void swap（ int *ｐ１,int *ｐ２） ;
int ａ，ｂ；
int *pointer_１,*pointer_２；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
pointer_１ ＝＆ａ； pointer_2 ＝＆ｂ；
if（ａ＜ｂ＝ swap（ pointer_１,pointer_2 ）；
printf（ ″\ｎ％ｄ，％ｄ \ｎ ″，ａ，ｂ）；
｝
void swap（ int *ｐ１,int *ｐ２）
｛ int temp；
temp＝ *ｐ 1；
*ｐ１＝ *ｐ２；
*ｐ２＝ temp；
｝
例 10.４ 输入ａ、ｂ、ｃ 3个整数，按大小顺序输出
#include <stdio.h>
void main（）
｛ void exchange（ int *ｑ 1,int *ｑ 2,int *ｑ 3） ;
int ａ，ｂ，ｃ,*ｐ１,*ｐ２,*ｐ３；
scanf（ ″%ｄ,%ｄ,%ｄ ″,&ａ,&ｂ,&ｃ）；
ｐ１＝＆ａ；ｐ２＝＆ｂ；ｐ３＝＆ｃ；
exchange （ｐ１，ｐ２，ｐ３）；
printf（ ″＼ｎ％ｄ,％ｄ,％ｄ＼ｎ ″,ａ,ｂ,ｃ）；
｝
void exchange（ int *ｑ１,int *ｑ２,int *ｑ３）
｛ void swap（ int *ｐｔ１,int *ｐｔ２） ;
if（ *ｑ１＜ *ｑ２） swap（ｑ１，ｑ２）；
if（ *ｑ１＜ *ｑ３） swap（ｑ１，ｑ３）；
if（ *ｑ２＜ *ｑ３＝ swap（ｑ２，ｑ３）；
｝
void swap（ int *ｐｔ１,int *ｐｔ２）
｛ int temp；
temp＝ *ｐｔ１；
*ｐｔ１＝ *ｐｔ２；
*ｐｔ２＝ temp；
｝
§ 10.3 数组与指针一个变量有地址，一个数组包含若干元素，每个数组元素都在内存中占用存储单元，它们都有相应的地址。指针变量既然可以指向变量，当然也可以指向数组元素（把某一元素的地址放到一个指针变量中）。所谓 数组元素的指针就是数组元素的地址 。
定义一个指向数组元素的指针变量的方法，与以前介绍的指向变量的指针变量相同。例如：
ｉｎｔ ａ［１０］；
(定义ａ为包含１０个整型数据的数组 )
*ｐ；
(定义ｐ为指向整型变量的指针变量 )
应当注意，如果数组为ｉｎｔ型，则指针变量的基类型亦应为ｉｎｔ型。
10.3.1 指向数组元素的指针对该指针变量赋值：
ｐ＝＆ａ［０］；
把ａ［０］元素的地址赋给指针变量ｐ。也就是使ｐ
指向ａ数组的第０号元素，如图：
10.３,２通过指针引用数组元素引用一个数组元素，可以用：
（１） 下标法，如ａ［ｉ］形式；
（２） 指针法，如 *（ａ＋ｉ）或 *（ｐ＋ｉ） 。
其中ａ是数组名，ｐ是指向数组元素的指针变量，其初值ｐ＝ａ。
例 10.5 输出数组中的全部元素假设有一个ａ数组，整型，有１０个元素。要输出各元素的值有三种方法：
(1)下标法
#include <stdio.h>
void main（）
｛ int ａ［１０］；
int ｉ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（ ″％ｄ ″，＆ａ［ｉ］）；
printf（ ″＼ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf（ ″％ｄ ″，ａ［ｉ］）；
｝
(2) 通过数组名计算数组元素地址，找出元素的值。
#include <stdio.h>
void main（）
｛ int ａ［１０］；
int ｉ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋ ）
scanf（ ″％ｄ ″，＆ａ［ｉ］）；
printf（ ″＼ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf（ ″％ｄ ″,*（ａ＋ｉ））；
｝
(3) 用指针变量指向数组元素。
#include <stdio.h>
void main（）
｛ int ａ［１０］；
int *ｐ，ｉ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（ ″％ｄ ″，＆ａ［ｉ］）；
printf（ ″＼ｎ ″）；
for（ｐ＝ａ；ｐ＜（ａ＋１０）；ｐ＋＋）
printf（ ″％ｄ ″,*ｐ）；
｝
例 10.６ 通过指针变量输出ａ数组的１０个元素。
有人编写出以下程序：
#include <stdio.h>
void main（）
｛ int *ｐ，ｉ，ａ［１０］；
ｐ＝ａ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋ ）
scanf（ ″％ｄ ″，ｐ＋＋）；
printf（ ″＼ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋ ）
printf（ ″％ｄ ″,*ｐ）；
｝
这个程序乍看起来好像没有什么问题。有的人即使已被告知此程序有问题，还是找不出它有什么问题。我们先看一下运行情况：
1 2 3 4 5 6 7 8 9 0↙
22153 234 0 0 30036 25202 11631 8259 8237 28483
显然输出的数值并不是ａ数组中各元素的值解决这个问题的办法，只要在第二个ｆｏｒ循环之前加一个赋值语句：
ｐ＝ａ；
#include <stdio.h>
void main（）
｛ int *ｐ，ｉ，ａ［１０］；
ｐ＝ａ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（ ″％ｄ ″，ｐ＋＋）；
printg（ ″＼ｎ ″）；
p=a;
for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋ ）
printf（ ″％ｄ ″,*ｐ）；
｝
10.３,3 用数组名作函数参数在第 8章 8.7节中介绍过可以用数组名作函数的参数如,void main（）
{iｆ（ int ａｒｒ [],int ｎ） ;
int ａｒｒａｙ［１０］；
┇
ｆ（ａｒｒａｙ，１０）；
┇
｝
void ｆ (int ａｒｒ［ ］,int ｎ )
{
┇
}
f (int arr［ ］,int n)
但在编译时是将 arr按指针变量处理的，相当于将函数 f的首部写成
f (int *arr,int n)
以上两种写法是等价的。
需要说明的是,C语言调用函数时虚实结合的方法都是采用,值传递,方式,当用变量名作为函数参数时传递的是变量的值,当用数组名作为函数参数时,由于数组名代表的是数组首元素地址,因此传递的值是地址,所以要求形参为指针变量 。
例 10．７ 将数组ａ中ｎ个整数按相反顺序存放
#include <stdio.h>
void main（）
｛ void inv（ int ｘ［ ］,int ｎ） ;
int ｉ，ａ［１０］＝｛３，７，９，１１，０，
６，７，５，４，２｝；
printf（ ″The original array:＼ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf （ ″％ｄ,″，ａ［ｉ］）；
printf（ ″＼ｎ ″）；
inv （ａ，１０）；
printf（ ″The array has been in verted,\ｎ ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf （ ″％ｄ,″，ａ［ｉ］）；
printf （ ″＼ｎ ″）；
｝
void inv（ int ｘ［ ］,int ｎ） /*形参 x是数组名 */
｛ int temp，ｉ，ｊ，ｍ＝（ｎ－１）／２；
for（ｉ＝０；ｉ＜＝ｍ；ｉ＋＋）
｛
ｊ＝ｎ－１－ｉ；
temp＝ｘ［ｉ］；
ｘ［ｉ］＝ｘ［ｊ］；
ｘ［ｊ］＝ temp；
｝
return；
｝
运行情况如下：
The original array：
３，７，９，１１，０，６，７，５，４，２，
The array has been inverted：
２，４，５，７，６，０，１１，９，７，３，
#include <stdio.h>
void main（）
｛ void inv（ int *ｘ,int ｎ） ;
int ｉ，ａ［１０］＝｛３，７，９，１１，０，
６，７，５，４，２｝；
printf（ ″The original array:＼ｎ ″ ）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf （ ″％ｄ,″，ａ［ｉ］）；
printf （ ″＼ｎ ″）；
inv（ａ，１０）；
printf （ ″The array has been in verted,\ｎ ″ ）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
printf （ ″％ｄ,″，ａ［ｉ］）；
printf （ ″＼ｎ ″）； ｝
对这个程序可以作一些改动。将函数 inv中的形参ｘ改成指针变量。
void inv（ int *ｘ,int ｎ） /*形参 x为指针变量 */
｛ int ｐ,temp,*ｉ,*ｊ，ｍ＝（ｎ－１）／２；
ｉ＝ｘ；ｊ＝ｘ＋ｎ－１；ｐ＝ｘ＋ｍ；
for（；ｉ＜＝ｐ；ｉ＋＋，ｊ－－）
｛ｔ emp＝ *ｉ； *ｉ＝ *ｊ； *ｊ＝ temp；｝
return；
｝
归纳起来，如果有一个实参数组，想在函数中改变此数组中的元素的值，实参与形参的对应关系有以下４种情况：
(1) 形参和实参都用数组名，如：
void main（） void ｆ （ int ｘ [ ］,int ｎ）
｛ int ａ［１０］； {
… …
ｆ （ａ，１０）； }
｝
(2) 实参用数组名，形参用指针变量。如：
void ｍａｉｎ（） void ｆ （ int *ｘ,int ｎ）
｛ int ａ［１０］； {
… …
ｆ （ａ，１０）； }
｝
(3)实参形参都用指针变量。例如：
void main（） void ｆ（ int *ｘ,int ｎ）
｛ int ａ［１０］,*p=a; {
┇ ┇
ｆ（ p，１０）； }
｝
(4) 实参为指针变量，形参为数组名。如：
void main（） void ｆ（ int x[ ],int ｎ）
｛ｉｎｔ ａ［１０］,*p=a； {
┇ ┇
ｆ（ p，１０）； }
｝
#include <stdio.h>
void main（）
{ void inv（ int *ｘ,int ｎ） ;
int ｉ，ａｒｒ［１０］,*ｐ＝ａｒｒ；
printf（ ″The original array:\n ″）；
for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋）
scanf（ ″％ｄ ″，ｐ）；
printf（ ″＼ｎ ″）；
ｐ＝ａｒｒ；
inv（ｐ，１０）； /* 实参为指针变量 */
printf（ ″The array has been inverted,＼ｎ ″）；
for（ｐ＝ａｒｒ；ｐ＜ａｒｒ＋１０；ｐ＋＋ ）
printf（ ″％ｄ ″,*ｐ）；
printf（ ″＼ｎ ″）；
｝
void inv（ int *ｘ,int ｎ）
｛ int ｐ，ｍ,temp,*ｉ,*ｊ；
ｍ＝（ｎ－１）／２；
ｉ＝ｘ；ｊ＝ｘ＋ｎ－１；ｐ＝ｘ＋ｍ；
for（；ｉ＜＝ｐ；ｉ＋＋，ｊ－－）
｛ｔ emp＝ *ｉ； *ｉ＝ *ｊ； *ｊ＝ temp；｝
return；
｝
例 10,9 用选择法对１０个整数按由大到小顺序排序
#include <stdio.h>
void main（）
{ void sort（ int ｘ［ ］,int ｎ） ;
int *ｐ，ｉ，ａ［ 10］；
ｐ＝ａ；
for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（ ″％ｄ ″，ｐ＋＋）；
ｐ＝ａ；
sort（ｐ，１０）；
for（ｐ＝ａ，ｉ＝０；ｉ＜１０；ｉ＋＋）
｛ｐｒｉｎｔｆ（ ″％ｄ ″,*ｐ）；ｐ＋＋；｝
｝
void sort（ int ｘ [ ],int ｎ）
｛ int ｉ，ｊ，ｋ，ｔ；
for（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋）
｛ｋ＝ｉ；
for（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋）
ｉｆ（ｘ［ｊ］＞ｘ［ｋ］）
ｋ＝ｊ；
ｉｆ（ｋ！＝ｉ）
｛ｔ＝ｘ［ｉ］；
ｘ［ｉ］＝ｘ［ｋ］；
ｘ［ｋ］＝ｔ；｝
｝
｝
10.３,４ 多维数组与指针用指针变量可以指向一维数组中的元素，也可以指向多维数组中的元素。但在概念上和使用上，多维数组的指针比一维数组的指针要复杂一些。
1,多维数组元素的地址先回顾一下多维数组的性质,可以认为二维数组是“数组的数组”，例,
定义 int a［ 3］［ 4］ ={{1,3,5,7}，｛９，１１，
１３，１５｝，｛１７，１９，２１，２３｝ }；
则二维数组 a是由 3个一维数组所组成的。设二维数组的首行的首地址为２０００,则表 示 形 式 含义 地 址
a 二维数组名，指向一维数组
a[0］，即 0行首地址
2000
a[0］,
*(a+0),
*a
0行 0列元素地址 2000
a+1,&a［ 1］ 1行首地址 2008
a［ 1］,*(a+1) 1行 0列元素 a[1][0]的地址 2008
A[1]+2,
*(a+1)+2,
&a[1][2]
1行 2列元素 a[1][2] 的地址 2012
*(a[1]+2),
*(*(a+1)+2),
a[1][2]
1行 2列元素 a［ 1］［ 2］的值 元素值为 13
例 10.１ 0 输出二维数组有关的值
#include <stdio.h>
＃ define FROMAT ″％ｄ，％ｄ＼ｎ ″
void main（）
｛ int ａ [3][4]＝｛ 1,3,5,7,9，１１，１３，
１５，１７，１９，２１，２３｝；
printf（ＦＯＲＭＡＴ，ａ,*ａ）；
printf（ＦＯＲＭＡＴ，ａ [0],*（ａ＋０））；
printf（ＦＯＲＭＡＴ，＆ａ [0]，＆ａ [0][0]）；
printf（ＦＯＲＭＡＴ，ａ [1]，ａ＋１）；
printf（ＦＯＲＭＡＴ，＆ａ [1][0],*（ａ +１） +０）；
printf（ＦＯＲＭＡＴ，ａ［２］,*（ａ＋２））；
printf（ＦＯＲＭＡＴ，＆ａ［２］，ａ＋２）；
printf（ＦＯＲＭＡＴ，ａ［１］［０］,*（ *（ａ＋
１）＋０））；
｝
某一次运行结果如下：
１５８，１５８ (0行首地址和 0行 0列元素地址 )
１５８，１５８ (0行 0列元素地址 )
１５８，１５８ (0行 0首地址和 0行 0列元素地址 )
１６６，１６６ (1行 0列元素地址和 1行首地址 )
１６６，１６６ (1行 0列元素地址 )
１７４，１７４ (2行 0列元素地址 )
１７４，１７４ (2行首地址 )
９，９ (1行 0列元素的值 )
2,指向多维数组元素的指针变量在了解上面的概念后，可以用指针变量指向多维数组的元素。
(1) 指向数组元素的指针变量例 10.11 用指针变量输出二维数组元素的值
#include <stdio.h>
void main（）
｛ int ａ [3][4]＝｛ 1,3,5,7,9,11,13,15,17,19,21,23｝；
int *ｐ；
for（ｐ＝ａ［０］；ｐ＜ａ［０］＋１２；ｐ＋＋）
｛ｉｆ（（ｐ－ａ［０］）％４＝＝０）
printf（ ″＼ｎ ″）；
printf（ ″％４ｄ ″,*ｐ）； ｝
｝
运行结果如下：
1 3 5 7
9 11 13 15
19 21 23
可将程序最后两个语句改为
printf（ ″addr＝％ｏ,value＝％ 2ｄ＼ｎ ″,ｐ,*ｐ）；
在 TC++环境下某一次运行时输出如下：
ａｄｄｒ＝２３６，ｖａｌｕｅ＝１
ａｄｄｒ＝２４０，ｖａｌｕｅ＝３
ａｄｄｒ＝２４２，ｖａｌｕｅ＝５
ａｄｄｒ＝２４４，ｖａｌｕｅ＝７
ａｄｄｒ＝２４６，ｖａｌｕｅ＝９
ａｄｄｒ＝２５０，ｖａｌｕｅ＝１１
ａｄｄｒ＝２５２，ｖａｌｕｅ＝１３
ａｄｄｒ＝２５４，ｖａｌｕｅ＝１５
ａｄｄｒ＝２５６，ｖａｌｕｅ＝１７
ａｄｄｒ＝２６０，ｖａｌｕｅ＝１９
ａｄｄｒ＝２６２，ｖａｌｕｅ＝２１
ａｄｄｒ＝２６４，ｖａｌｕｅ＝２３
(2) 指向由ｍ个元素组成的一维数组的指针变量例 10.13 出二维数组任一行任一列元素的值
#include <stdio.h>
void main ( )
｛ int ａ［３］［４］＝｛ 1,3,5,7,9,11，
13,15，１７，１９，２１，２３｝；
int （ *ｐ）［４］，ｉ，ｊ；
ｐ＝ａ；
scanf（ ″ ｉ＝％ｄ，ｊ＝％ｄ ″，＆ｉ，＆ｊ）；
printf（ ″ａ［％ｄ，％ｄ］＝％ｄ＼ｎ ″，ｉ，
ｊ,*（ *（ｐ＋ｉ）＋ｊ））；
｝
运行情况如下：
ｉ＝１，ｊ＝２ ↙ （本行为键盘输入）
ａ［１，２］＝１３
运行情况如下：
ｉ＝１，ｊ＝２ ↙ （本行为键盘输入）
ａ［１，２］＝１３
3,用指向数组的指针作函数参数例 10.13 有一个班，３个学生，各学４门课，计算总平均分数以及第ｎ个学生的成绩。这个题目是很简单的。只是为了说明用指向数组的指针作函数参数而举的例子。用函数ａｖｅｒａｇｅ求总平均成绩，用函数ｓｅａｒｃｈ找出并输出第ｉ个学生的成绩。
#include <sydio.h>
void main（）
{ void average（ float *p,int n）；
void search（ float (*p）［ 4］,int n)；
float score［ 3］［ 4］ ={{65,67,70,60},{80，
87,90,81},{90,99,100,98}};
average（ *score,12）； ／ *求 12个分数的平均分 *／
search（ score，２）； ／ *求序号为２的学生的成绩 *／
｝
void average（ float *ｐ,int ｎ）
{ float *ｐ _ｅｎｄ；
float ｓｕｍ＝０，ａｖｅｒ；
ｐ _ｅｎｄ＝ｐ＋ｎ－１；
ｆｏｒ（；ｐ＜＝ｐ _ｅｎｄ；ｐ＋＋）
ｓｕｍ＝ｓｕｍ＋（ *ｐ）；
ａｖｅｒ＝ｓｕｍ／ｎ；
printf（ ″average＝％５．２ｆ＼ｎ ″,aver）；
｝
void search（ float (*ｐ )[4],int ｎ）
/ * p是指向具有 4个元素的一维数组的指针 */
｛ int ｉ；
printf（ ″the score of No,%ｄ are：＼ｎ ″，ｎ）；
for（ｉ＝０；ｉ＜４；ｉ＋＋ )
printf（ ″％ 5.2ｆ ″,*（ *（ｐ＋ｎ）＋ｉ））；
｝
程序运行结果如下：
ａｖｅｒａｇｅ＝８２．２５
ｔｈｅ ｓｃｏｒｅ ｏｆ Ｎｏ．２ ａｒｅ：
９０,００ ９９,００ １００,００ ９８,００
例 10.１ 4 在上题基础上，查找有一门以上课程不及格的学生，打印出他们的全部课程的成绩。
#include <stdio.h>
void main（）
｛ void search（ float (*p)［ 4］,int n）； /*函数声明 */
float score[3][4]={{65,57,70,60},{58,87，
90,81},{90,99,100,98}};
search（ score，３）；
｝
void search（ float (*p)［ 4］,int ｎ）
｛ int ｉ，ｊ，ｆｌａｇ；
for（ｊ＝０；ｊ＜ｎ；ｊ＋＋ )
｛ flag＝０；
for（ｉ＝０；ｉ＜４；ｉ＋＋ )
if（ *（ *（ｐ＋ｊ）＋ｉ）＜６０ ) flag＝１；
if（ｆｌａｇ＝＝１）
{ printf("No.%d fails,his scores are:＼ n",j+1);
for（ｉ＝０；ｉ＜４；ｉ＋＋）
printf（ ″%５,１ｆ ″,*(*(ｐ＋ｊ )＋ｉ ))；
printf（ ″＼ｎ ″）；
｝
｝
｝
程序运行结果如下：
Ｎｏ．１ ｆａｉｌ s，ｈｉｓ ｓｃｏｒｅｓ ａｒｅ：
６５,０ ５７,０ ７０,０ ６０,０
Ｎｏ．２ ｆａｉｌ s，ｈｉｓ ｓｃｏｒｅｓ ａｒｅ ∶
５８,０ ８７,０ ９０,０ ８１,０
§ 10.４ 字符串与指针
10．４．１字符串的表示形式例 10.１ 5 定义一个字符数组，对它初始化，
然后输出该字符串
#include <stdio.h>
void main（）
｛ char string［］＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
printf（ ″％ｓ＼ｎ ″，ｓｔｒｉｎｇ）；
｝
(1) 用字符数组存放一个字符串，然后输出该字符串。
(2) 用字符指针指向一个字符串可以不定义字符数组，而定义一个字符指针。用字符指针指向字符串中的字符。
例 10．１ 6 定义字符指针
#include <stdio.h>
void main（）
｛ char string＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
printf（ ″％ｓ＼ｎ ″，ｓｔｒｉｎｇ）；
｝
例 10.１ 7 将字符串ａ复制为字符串ｂ
对字符串中字符的存取，可以用下标方法，也可以用指针方法
#include <stdio.h>
void ｍａｉｎ（）
｛ char ａ [ ]＝ ″Ｉ am a boy,″，ｂ [20]；
int ｉ；
for（ｉ＝０； *（ａ＋ｉ）！＝ ′＼０ ′；ｉ＋＋）
*（ｂ＋ｉ）＝ *（ａ＋ｉ）；
*（ｂ＋ｉ）＝ ′＼０ ′；
printf（ ″string a is,％ｓ＼ｎ ″，ａ）；
printf（ ″ｓｔｒｉｎｇ ｂ ｉｓ,″）；
for（ｉ＝０；ｂ［ｉ］！＝ ′＼０ ′；ｉ＋＋）
printf（ ″％ｃ ″，ｂ［ｉ］）；
printf（ ″＼ｎ ″）；
｝
也可以设指针变量，用它的值的改变来指向字符串中的不同的字符。
例 10.１ 8 用指针变量来处理例 10．１ 7问题。
#include <stdio.h>
void main（）
｛ char ａ [ ] =″I am a boy,″，ｂ [20],*p1,*p2；
int ｉ；
ｐ１＝ａ；ｐ２＝ｂ；
for（； *ｐ１！＝ ′＼０ ′； p1＋＋,p2＋＋）
*ｐ２＝ *ｐ１；
*ｐ２＝ ′＼０ ′；
printf（ ″string ａ is：％ｓ＼ｎ ″，ａ）；
printf（ ″ｓｔｒｉｎｇ ｂ ｉｓ,″）；
for（ｉ＝０；ｂ［ｉ］！＝ ′＼０ ′；ｉ＋＋）
printf（ ″％ｃ ″，ｂ［ｉ］）；
printf（ ″＼ｎ ″）；
｝
程序必须保证使ｐ１和ｐ２同步移动。
10.４,２ 字符指针作函数参数例 10,19 用函数调用实现字符串的复制
#include <stdio.h>
void main（）
{ void copy_string（ char from［ ］,char to［ ］） ;
char a[ ]=″Ｉ am a teacher,″；
char ｂ [ ]=″you are a student,″；
printf(“string a=％ｓ＼ｎ string ｂ＝％ｓ＼ｎ ″，
ａ，ｂ )；
printf("copy string a to string b:\n ");
copy_string （ａ，ｂ）；
printf("＼ nstring a=%s＼ nstring b=%s＼ n",a,b);
｝
(1) 用字符数组作参数
void copy_string（ char from［ ］,char to［ ］）
｛ int ｉ＝０；
while（ｆｒｏｍ［ｉ］！＝ ′＼０ ′）
｛ｔｏ［ｉ］＝ｆｒｏｍ［ｉ］；ｉ＋＋；｝
ｔｏ［ｉ］＝ ′＼０ ′；
｝
程序运行结果如下：
ｓｔｒｉｎｇ ａ＝Ｉ ａｍ ａ ｔｅａｃｈｅｒ．
ｓｔｒｉｎｇ ｂ＝ｙｏｕ ａｒｅ ａ ｓｔｕｄｅｎｔ．
copy string a to string b:
ｓｔｒｉｎｇ ａ＝Ｉ ａｍ ａ ｔｅａｃｈｅｒ．
ｓｔｒｉｎｇ ｂ＝Ｉ ａｍ ａ ｔｅａｃｈｅｒ．
（２） 形参用字符指针变量
#include <stdio.h>
void main（）
{ void copy_string（ char *ｆｒｏｍ,char *ｔｏ） ;
char *ａ＝ ″Ｉ am a teacher,″；
char *ｂ＝ ″you are a student,″；
printf("string a=％ｓ＼ｎｓｔｒｉｎｇ ｂ＝％
ｓ＼ｎ ″，ａ，ｂ )；
printf("copy string a to string b:\n ");
ｃｏｐｙ _ｓｔｒｉｎｇ（ａ，ｂ）；
printf("＼ nstring a=%s＼ nstring b=%s＼ n",a，
b);
｝
void copy_string（ char *ｆｒｏｍ,char *ｔｏ）
｛ for（； *from！＝ ′＼０ ′； from＋＋,to＋＋）
*
*ｔｏ＝ ′＼０ ′；
｝
（３） 对 copy_string 函数还可作简化
1、将 copy_string函数改写为
void copy_string （ char *ｆｒｏｍ,char *ｔｏ）
｛ while（（ *ｔｏ＝ *ｆｒｏｍ）！＝ ′＼０ ′）
｛ｔｏ＋＋；ｆｒｏｍ＋＋；｝
｝
2,copy_string函数的函数体还可改为
｛
while（（ *to＋＋＝ *from＋＋）！＝ ′＼０ ′）；
｝
3,copy_string函数的函数体还可写成
{
while（ *ｆｒｏｍ！＝ ′＼０ ′）
*ｔｏ＋＋＝ *ｆｒｏｍ＋＋；
*ｔｏ＝ ′＼０ ′；
｝
4、上面的 while语句还可以进一步简化为下面的 while
语句：
while（ *ｔｏ＋＋＝ *ｆｒｏｍ＋＋）；
它与下面语句等价：
while（（ *to＋＋＝ *from＋＋）！＝ ′＼０ ′）；
将 *ｆｒｏｍ赋给 *ｔｏ，如果赋值后的 *ｔｏ值等于 ′
＼０ ′，则循环终止（ ′＼０ ′已赋给 *ｔｏ）
5、函数体中ｗｈｉｌｅ语句也可以改用ｆｏｒ语句：
for（；（ *to＋＋＝ *from＋＋）！＝０；）；
或
for（； *to＋＋＝ *from＋＋；）；
6、也可用指针变量，函数 copy_string可写为
void copy_string （ char from［ ］,char ｔｏ［ ］）
*ｐ１,*ｐ２；
ｐ１＝ｆｒｏｍ；ｐ２＝ｔｏ；
while（（ *p2＋＋＝ *p1＋＋）！＝ ′＼０ ′）；
｝
10.４,３ 对使用字符指针变量和字符数组的讨论虽然用字符数组和字符指针变量都能实现字符串的存储和运算，但它们二者之间是有区别的，不应混为一谈，主要有以下几点：
(1) 字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的是地址（字符串第 1
个字符的地址），决不是将字符串放到字符指针变量中。
(2)赋值方式。对字符数组只能对各个元素赋值，不能用以下办法对字符数组赋值。
char str［１４］；
str＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
而对字符指针变量，可以采用下面方法赋值：
char *ａ；
ａ＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
但注意赋给ａ的不是字符，而是字符串第一个元素的地址。
(3)对字符指针变量赋初值：
char *ａ＝ ″Ｉ love China！ ″；等价于
char *ａ；
ａ＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
而对数组的初始化：
char str［１４］＝｛ ″Ｉ love China！ ″｝ ;
不能等价于
char str［１４］；
str［ ］＝ ″Ｉ ｌｏｖｅ Ｃｈｉｎａ！ ″；
(4) 如果定义了一个字符数组，在编译时为它分配内存单元，它有确定的地址。而定义一个字符指针变量时，给指针变量分配内存单元，在其中可以放一个字符变量的地址也就是说，该指针变量可以指向一个字符型数据，但如果未对它赋予一个地址值，
则它并未具体指向一个确定的字符数据。
如,char str［１０］；
scanf（ ″％ｓ ″,str）； 是可以的。
而常有人用下面的方法,目的是想输入一个字符串，虽然一般也能运行，但这种方法是危险的,
char *ａ；
scanf（ ″％ｓ ″，ａ）；
应当这样：
*ａ，ｓｔｒ［１０］；
ａ＝ｓｔｒ；
ｓｃａｎｆ（ ″％ｓ ″，ａ）；
(5) 指针变量的值是可以改变的，如：
例 10.２ 0 改变指针变量的值
#include <stdio.h>
void ｍａｉｎ（）
｛ char *ａ＝ ″I love China！ ″；
ａ＝ａ＋７；
printf（ ″％ｓ ″，ａ）；
｝
需要说明，若定义了一个指针变量，并使它指向一个字符串，就可以用下标形式引用指针变量所指的字符串中的字符。例 10．２ 1
#include <stdio.h>
void main（）
｛ char *ａ＝ ″Ｉ love Ｃ hina!″；
int ｉ；
printf (,The sixth character is %c＼ n",a［ 5］ );
for（ｉ＝０；ａ［ｉ］！＝ ′＼０ ′；ｉ＋＋）
printf（ ″％ｃ ″，ａ［ｉ］）；
｝
10.５ 指向函数的指针
10.５,１ 用函数指针变量调用函数可以用指针变量指向整型变量、字符串、数组，
也可以指向一个函数。一个函数在编译时被分配给一个入口地址。这个 函数的入口地址就称为函数的指针 。
例 10.２ 2 求ａ和ｂ中的大者。先列出按一般方法的程序。
#include <stdio.h>
void main（）
｛ int max（ int,int）；
int ａ，ｂ，ｃ；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
ｃ＝ｍａｘ（ａ，ｂ）；
printf（ ″ａ＝％ｄ，ｂ＝％ｄ，ｍａｘ＝％ｄ
″，ａ，ｂ，ｃ）；
｝
int max（ int ｘ,int ｙ）
｛ int ｚ；
if（ｘ＞ｙ）ｚ＝ｘ；
else ｚ＝ｙ；
return（ｚ）；
｝
将 main 函数改写为
#include <stdio.h>
void main（）
｛ int ｍａｘ（ int,int）；
int （ *ｐ）（）；
int ａ，ｂ，ｃ；
ｐ＝ｍａｘ；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
ｃ＝（ *ｐ）（ａ，ｂ）；
printf（ ″ａ＝％ｄ，ｂ＝％ｄ，ｍａｘ＝％
ｄ ″，ａ，ｂ，ｃ）；
｝
10.５,２ 用指向函数的指针作函数参数函数指针变量常用的用途之一是把指针作为参数传递到其他函数。前面介绍过，函数的参数可以是变量、
指向变量的指针变量、数组名、指向数组的指针变量等。现在介绍指向函数的指针也可以作为参数，以实现函数地址的传递，这样就能够在被调用的函数中使用实参函数。它的原理可以简述如下：有一个函数
（假设函数名为 sub），它有两个形参（ x1和 x2），
定义 x1和 x2为指向函数的指针变量。在调用函数 sub
时，实参为两个函数名ｆ１和ｆ２，给形参传递的是函数ｆ１和ｆ２的地址。这样在函数ｓｕｂ中就可以调用ｆ１和ｆ２函数了。
实参函数名 f1 ｆ２
↓ ↓
void ｓｕｂ（ int (*x1)(int),int (*x2)(int,int)）
｛ int ａ，ｂ，ｉ，ｊ；
ａ＝（ *ｘ１）（ｉ）； ／ *调用ｆ１函数 *／
ｂ＝（ *ｘ２）（ｉ，ｊ）； ／ *调用ｆ２函数 *／
…
｝
例 10.２ 3 设一个函数 process，在调用它的时候，每次实现不同的功能。输入ａ和ｂ两个数，第一次调用
process时找出ａ和ｂ中大者，第二次找出其中小者，
第三次求ａ与ｂ之和。
#include <stdio.h>
void main（）
｛ int max（ int,int） ; /* 函数声明 */
int min（ int,int） ; /* 函数声明 */
int add（ int,int）； /* 函数声明 */
void process (int,int,int(*fun)(); /* 函数声明 */
int ａ，ｂ；
printf（ ″ｅｎｔｅｒ ａ ａｎｄ ｂ,″）；
scanf（ ″％ｄ，％ｄ ″，＆ａ，＆ｂ）；
ｐｒｉｎｔｆ（ ″ｍａｘ＝ ″）；
ｐｒｏｃｅｓｓ（ａ，ｂ，ｍａｘ）；
ｐｒｉｎｔｆ（ ″ｍｉｎ＝ ″）；
ｐｒｏｃｅｓｓ（ａ，ｂ，ｍｉｎ）；
ｐｒｉｎｔｆ（ ″ｓｕｍ＝ ″）；
ｐｒｏｃｅｓｓ（ａ，ｂ，ａｄｄ）；
｝
int ｍａｘ（ int ｘ,int ｙ） /* 函数定义 */
｛ｉｎｔ ｚ；
ｉｆ（ｘ＞ｙ）ｚ＝ｘ；
ｅｌｓｅ ｚ＝ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
int ｍｉｎ（ int ｘ,int ｙ） /* 函数定义 */
｛ｉｎｔ ｚ；
ｉｆ（ｘ＜ｙ）ｚ＝ｘ；
ｅｌｓｅ ｚ＝ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
int ａｄｄ（ int ｘ,int ｙ） /* 函数定义 */
｛ｉｎｔ ｚ；
ｚ＝ｘ＋ｙ；
ｒｅｔｕｒｎ（ｚ）；
｝
void process(int ｘ,int ｙ,int (*fun)(int,int))
｛ｉｎｔ ｒｅｓｕｌｔ；
ｒｅｓｕｌｔ＝（ *ｆｕｎ）（ｘ，ｙ）；
ｐｒｉｎｔｆ（ ″％ｄ＼ｎ ″，ｒｅｓｕｌｔ）；
｝
10.６ 返回指针值的函数一个函数可以带回一个整型值、字符值、实型值等，
也可以带回指针型的数据，即地址。其概念与以前类似，只是带回的值的类型是指针类型而已。
这种带回指针值的函数，一般定义形式为类型名 *函数名（参数表列） ;
例如：
ｉｎｔ *ａ（ int ｘ,int ｙ） ;
例 10．２ 4 有若干个学生的成绩（每个学生有４门课程），要求在用户输入学生序号以后，能输出该学生的全部成绩。用指针函数来实现。
#include <stdio.h>
void main（）
｛ float *score［ ］［ 4］ ={{60,70,80,90}，
{56,89,67,88},{34,78,90,66}};
float *search（ float (*pointer)［ 4］,int n）；
float *ｐ；
int ｉ，ｍ；
printf（ ″enter the number of student,″）；
scanf（ ″％ｄ ″，＆ｍ）；
printf（ ″The scores of No．％ｄ are,\ｎ ″，ｍ）；
ｐ＝ search（ｓｃｏｒｅ，ｍ）；
for（ｉ＝０；ｉ＜４；ｉ＋＋＝
printf（ ″％５．２ｆ＼ｔ ″,*（ｐ＋ｉ））；
｝
float * search（ float (*ｐｏｉｎｔｅｒ )［ 4］,int ｎ）
｛ float *ｐｔ；
ｐｔ＝ *（ｐｏｉｎｔｅｒ＋ｎ）；
return（ｐｔ）；
｝
运行情况如下：
enter the number of student,１ ↙
The scores of No,１ are：
56.00 89.00 67.00 88.00
例 10．２ 5 对上例中的学生，找出其中有不及格课程的学生及其学生号。
#include <stdio.h>
void main（）
{float score［ ］［ 4］ ={{60,70,80,90},{56，
89,67,88},{34,78,90,66}};
float search（ float (*pointer)［ 4］）；
float *ｐ；
iｎｔ ｉ，ｊ；
fｏｒ（ｉ＝０；ｉ＜３；ｉ＋＋）
｛ｐ＝ｓｅａｒｃｈ（ｓｃｏｒｅ＋ｉ）；
ｉｆ（ｐ＝＝ *（ｓｃｏｒｅ＋ｉ））
｛ printf（ ″Ｎｏ．％ｄ scores,″，ｉ）；
for（ｊ＝０；ｊ＜４；ｊ＋＋ )
printf（ ″％５．２ｆ ″,*（ｐ＋ｊ））；
printf（ ″＼ｎ ″）；｝
｝
｝
10.７指针数组和指向指针的指针
10.７,１ 指针数组的概念一个数组，若其元素均为指针类型数据，称为 指针数组,也就是说，指针数组中的每一个元素都相当于一个指针变量。一维指针数组的定义形式为例如：
*ｐ [４ ]；
例 10．２ 6 将若干字符串按字母顺序（由小到大）输出。
#include <stdio.h>
#include <string.h>
void main（）
｛ void sort（ char *name［ ］,int n）；
void printf（ char *name［ ］,int n）；
char *name［ ］ ={"Follow me","BASIC","Great
Wall″,"FORTRAN","Computer design"};
int ｎ＝５；
sort（ｎａｍｅ，ｎ）；
print（ｎａｍｅ，ｎ）；
｝
void sort（ char *ｎａｍｅ［ ］,int ｎ）
｛ char *ｔｅｍｐ；
int ｉ，ｊ，ｋ；
for（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋＝
｛ｋ＝ｉ；
for（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋＝
if（ strcmp（ name[ｋ ],name[ｊ ]） >0）ｋ =ｊ；
if（ｋ !＝ｉ）
temp=name［ i］ ;
name［ i］ =name［ k］ ;
name［ k］ =temp;｝
｝
｝
void print（ char *ｎａｍｅ［ ］,int ｎ）
｛ｉｎｔ ｉ；
ｆｏｒ（ｉ＝０；ｉ＜ｎ；ｉ＋＋）
printf（ ″％ｓ＼ｎ ″，ｎａｍｅ［ｉ］）；
}
运行结果为：
ＢＡＳＩＣ
Ｃｏｍｐｕｔｅｒ ｄｅｓｉｇｎ
ＦＯＲＴＲＡＮ
Ｆｏｌｌｏｗ ｍｅ
Ｇｒｅａｔ Ｗａｌｌ
10．７．２ 指向指针的指针怎样定义一个指向指针数据的指针变量呢？ 如下：
**ｐ；
ｐ的前面有两个 *号。 *运算符的结合性是从右到左，
因此 **ｐ相当于 *（ *ｐ），显然 *ｐ是指针变量的定义形式。如果没有最前面的 *，那就是定义了一个指向字符数据的指针变量。现在它前面又有一个
*号，表示指针变量ｐ是指向一个字符指针变量的。
*ｐ就是ｐ所指向的另一个指针变量。
例 10．２ 7 使用指向指针的指针
#include <stdio.h>
void main（）
｛ char *name［］ ={"Follow me","BASIC","Great
Wall″,"FORTRAN","Computer design"};
char **ｐ；
int ｉ；
for（ｉ＝０；ｉ＜５；ｉ＋＋）
｛ｐ＝ｎａｍｅ＋ｉ；
printf（ ″％ｓ＼ｎ ″,*ｐ）；
｝
｝
例 10.28 一个指针数组的元素指向整型数据的简单例子
#include <stdio.h>
void main（）
｛ int ａ［５］＝｛１，３，５，７，９｝；
int *num［ 5］ =｛ &a［ 0］,&a［ 1］，
&a［ 2］,&a［ 3］,&a［ 4］｝；
int **ｐ，ｉ；
ｐ＝ｎｕｍ；
for（ｉ＝０；ｉ＜５；ｉ＋＋＝
｛ printf（ ″％ｄ ″,**ｐ）；
ｐ＋＋；
｝
｝
10.７,３ 指针数组作ｍａｉｎ函数的形参指针数组的一个重要应用是作为 main函数的形参。在以往的程序中，ｍａｉｎ函数的第一行一般写成以下形式,void main（）
括弧中是空的。实际上,main函数可以有参数，例如：
void main（ int argc,char *argv[ ]）
argc和 argv就是 main函数的形参。 main函数是由操作系统调用的。那么,main函数的形参的值从何处得到呢？
显然不可能在程序中得到。实际上实参是和命令一起给出的。也就是在一个命令行中包括命令名和需要传给 main函数的参数。命令行的一般形式为 命令名 参数
１ 参数２ …… 参数ｎ
如果有一个名为ｆｉｌｅ１的文件，它包含以下的ｍ
ａｉｎ函数,
void main（ int ａｒｇｃ,char *ａｒｇｖ［ ］）
｛ｗｈｉｌｅ（ａｒｇｃ＞１）
｛＋＋ａｒｇｖ；
ｐｒｉｎｔｆ（ ″％ｓ＼ｎ ″
－－ａｒｇｃ；
｝
｝
在 DOS命令状态下输入的命令行为
ｆｉｌｅ１ Ｃｈｉｎａ Ｂｅｉｊｉｎｇ
则执行以上命令行将会输出以下信息：
Ｃｈｉｎａ
Ｂｅｉｊｉｎｇ
10.８有关指针的数据类型和指针运算的小结
10.8.1有关指针的数据类型的小结定义 含义
ｉｎｔ ｉ； 定义整型变量ｉ
*ｐ； ｐ为指向整型数据的指针变量
int a［ n］ ; 定义整型数组ａ，它有ｎ个元素
ｉｎｔ *ｐ［ｎ］； 定义指针数组ｐ，它由ｎ个指向整型数据的指针元素组成
ｉｎｔ （ *ｐ）［ｎ］； ｐ为指向含ｎ个元素的一维数组的指针变量
ｉｎｔ ｆ（）； ｆ为带回整型函数值的函数
ｉｎｔ *ｐ（）； ｐ为带回一个指针的函数，该指针指向整型数据
ｉｎｔ （ *ｐ）（）； ｐ为指向函数的指针，该函数返回一个整型值
ｉｎｔ **ｐ； ｐ是一个指针变量，它指向一个指向整型数据的指针变量
10.8.2 指针运算小结
(1) 指针变量加（减）一个整数例如：ｐ＋＋、ｐ－－、ｐ＋ｉ、ｐ－ｉ、ｐ＋＝ｉ、
ｐ－＝ｉ等。
(2) 指针变量赋值将一个变量地址赋给一个指针变量。如：
ｐ＝＆ａ； （将变量ａ的地址赋给ｐ）
ｐ＝ array； （将数组ａｒｒａｙ首元素地址赋给ｐ）
ｐ＝＆ array［ｉ］；（将数组ａｒｒａｙ第ｉ个元素的地址赋给ｐ）
ｐ＝ max；（ｍａｘ为已定义的函数，将ｍａｘ的入口地址赋给ｐ）
ｐ１＝ｐ２；（ｐ１和ｐ２都是指针变量，将ｐ２的值赋给ｐ１）
(3) 指针变量可以有空值，即该指针变量不指向任何变量,可以这样表示,ｐ＝ＮＵＬＬ ；
(4) 两个指针变量可以相减如果两个指针变量都指向同一个数组中的元素，则两个指针变量值之差是两个指针之间的元素个数
(5) 两个指针变量比较若两个指针指向同一个数组的元素，则可以进行比较。
指向前面的元素的指针变量“小于”指向后面元素的指针变量。
10.8.3 void指针类型
ANSIC新标准增加了一种,void”指针类型，即可定义一个指针变量，但不指定它是指向哪一种类型数据的。
ANSIC标准规定用动态存储分配函数时返回 void指针，
它可以用来指向一个抽象的类型的数据，在将它的值赋给另一指针变量时要进行强制类型转换使之适合于被赋值的变量的类型。例如,
*ｐ１；
*ｐ２；
…
ｐ１＝（ｃｈａｒ *）ｐ２；
同样可以用（ｖｏｉｄ *）ｐ１将ｐ１的值转换成
ｖｏｉｄ *类型。如：
ｐ２＝（ｖｏｉｄ *）ｐ１；
也可以将一个函数定义为ｖｏｉｄ *类型，如,
ｖｏｉｄ *ｆｕｎ（ char ch1,char ch2）
表示函数ｆｕｎ返回的是一个地址，它指向“空类型”，如需要引用此地址，也需要根据情况对之进行类型转换，如对该函数调用得到的地址要进行以下转换：
ｐ１＝（ｃｈａｒ *）ｆｕｎ（ｃ h１，ｃ h２）；
