它的定义为：

int a[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}}

设数组 a 的首地址为 1000，各下标变量的首地址及其值如图所示。

谭浩强 C 语言程序设计 2001 年 5 月 1 日

前面介绍过，Ｃ语言允许把一个二维数组分解为多个一维数组来处理。因此数组 a 可分

解为三个一维数组，即 a[0]，a[1]，a[2]。每一个一维数组又含有四个元素。

例如 a[0]数组，含有 a[0][0]，a[0][1]，a[0][2]，a[0][3]四个元素。

数组及数组元素的地址表示如下：

从二维数组的角度来看，a 是二维数组名，a 代表整个二维数组的首地址，也是二维数

组 0 行的首地址，等于 1000。a+1 代表第一行的首地址，等于 1008。如图：

a[0]是第一个一维数组的数组名和首地址，因此也为 1000。*(a+0)或*a 是与 a[0]等效

的， 它表示一维数组 a[0]0 号元素的首地址，也为 1000。&a[0][0]是二维数组 a 的 0 行 0

列元素首地址，同样是 1000。因此，a，a[0]，*(a+0)，*a，&a[0][0]是相等的。

同理，a+1 是二维数组 1 行的首地址，等于 1008。a[1]是第二个一维数组的数组名和首

地址，因此也为 1008。&a[1][0]是二维数组 a 的 1 行 0 列元素地址，也是 1008。因此

a+1,a[1],*(a+1),&a[1][0]是等同的。

由此可得出：a+i，a[i]，*(a+i)，&a[i][0]是等同的。

此外，&a[i]和 a[i]也是等同的。因为在二维数组中不能把&a[i]理解为元素 a[i]的地

址，不存在元素 a[i]。Ｃ语言规定，它是一种地址计算方法，表示数组 a 第 i 行首地址。

由此，我们得出：a[i]，&a[i]，*(a+i)和 a+i 也都是等同的。

另外，a[0]也可以看成是 a[0]+0，是一维数组 a[0]的 0 号元素的首地址，而 a[0]+1

则是 a[0]的 1 号元素首地址，由此可得出 a[i]+j 则是一维数组 a[i]的 j 号元素首地址，它

等于&a[i][j]。

谭浩强 C 语言程序设计 2001 年 5 月 1 日

由 a[i]=*(a+i)得 a[i]+j=*(a+i)+j。由于*(a+i)+j 是二维数组 a 的 i 行 j 列元素的首

地址，所以，该元素的值等于*(*(a+i)+j)。

【例 10.22】

main(){

int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

printf("%d,",a);

printf("%d,",*a);

printf("%d,",a[0]);

printf("%d,",&a[0]);

printf("%d\n",&a[0][0]);

printf("%d,",a+1);

printf("%d,",*(a+1));

printf("%d,",a[1]);

printf("%d,",&a[1]);

printf("%d\n",&a[1][0]);

printf("%d,",a+2);

printf("%d,",*(a+2));

printf("%d,",a[2]);

printf("%d,",&a[2]);

printf("%d\n",&a[2][0]);

printf("%d,",a[1]+1);

printf("%d\n",*(a+1)+1);

printf("%d,%d\n",*(a[1]+1),*(*(a+1)+1));

2. 指向多维数组的指针变量

把二维数组 a 分解为一维数组 a[0],a[1],a[2]之后，设 p 为指向二维数组的指针变量。

可定义为：

int (*p)[4]

它表示 p 是一个指针变量，它指向包含 4 个元素的一维数组。若指向第一个一维数组

a[0]，其值等于 a,a[0]，或&a[0][0]等。而 p+i 则指向一维数组 a[i]。从前面的分析可得

出*(p+i)+j 是二维数组 i 行 j 列的元素的地址，而*(*(p+i)+j)则是 i 行 j 列元素的值。

二维数组指针变量说明的一般形式为：

谭浩强 C 语言程序设计 2001 年 5 月 1 日

类型说明符 (*指针变量名)[长度]

其中“类型说明符”为所指数组的数据类型。“*”表示其后的变量是指针类型。“长度”表示

二维数组分解为多个一维数组时，一维数组的长度，也就是二维数组的列数。应注意“(*指

针变量名)”两边的括号不可少，如缺少括号则表示是指针数组(本章后面介绍)，意义就完

全不同了。

【例 10.23】

main(){

int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

int(*p)[4];

int i,j;

p=a;

for(i=0;i<3;i++)

{for(j=0;j<4;j++) printf("%2d ",*(*(p+i)+j));

printf("\n");}

10.4 字符串的指针指向字符串的针指变量

10.4.1 字符串的表示形式

在 C 语言中，可以用两种方法访问一个字符串。

1) 用字符数组存放一个字符串，然后输出该字符串。

【例 10.24】

main(){

char string[]=”I love China!”;

printf("%s\n",string);

说明：和前面介绍的数组属­性­一样，string 是数组名，它代表字符数组的首地址。

2) 用字符串指针指向一个字符串。

【例 10.25】

main(){

char *string=”I love China!”;

printf("%s\n",string);

谭浩强 C 语言程序设计 2001 年 5 月 1 日

字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针

变量的赋值不同来区别。对指向字符变量的指针变量应赋予该字符变量的地址。

如：

char c,*p=&c;

表示 p 是一个指向字符变量 c 的指针变量。

而：

char *s="C Language";

则表示 s 是一个指向字符串的指针变量。把字符串的首地址赋予 s。

上例中，首先定义 string 是一个字符指针变量，然后把字符串的首地址赋予 string(应

写出整个字符串，以便编译系统把该串装入连续的一块内存单元)，并把首地址送入 string。

程序中的：

char *ps="C Language";

等效于：

char *ps;

ps="C Language";

【例 10.26】输出字符串中 n 个字符后的所有字符。

main(){

char *ps="this is a book";

int n=10;

ps=ps+n;

printf("%s\n",ps);

运行结果为：

book

谭浩强 C 语言程序设计 2001 年 5 月 1 日

在程序中对 ps 初始化时，即把字符串首地址赋予 ps，当 ps= ps+10 之后，ps 指向字符

“b”，因此输出为"book"。

【例 10.27】在输入的字符串中查找有无‘k’字符。

main(){

char st[20],*ps;

int i;

printf("input a string:\n");

ps=st;

scanf("%s",ps);

for(i=0;ps[i]!='\0';i++)

if(ps[i]=='k'){

printf("there is a 'k' in the string\n");

break;

if(ps[i]=='\0') printf("There is no 'k' in the string\n");

【例 10.28】本例是将指针变量指向一个格式字符串，用在 printf 函数中，用于输出二维

数组的各种地址表示的值。但在 printf 语句中用指针变量 PF 代替了格式串。 这也是程序

中常用的方法。

main(){

static int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

char *PF;

PF="%d,%d,%d,%d,%d\n";

printf(PF,a,*a,a[0],&a[0],&a[0][0]);

printf(PF,a+1,*(a+1),a[1],&a[1],&a[1][0]);

printf(PF,a+2,*(a+2),a[2],&a[2],&a[2][0]);

printf("%d,%d\n",a[1]+1,*(a+1)+1);

printf("%d,%d\n",*(a[1]+1),*(*(a+1)+1));

【例 10.29】本例是把字符串指针作为函数参数的使用。要求把一个字符串的内容复制到另

一个字符串中，并且不能使用 strcpy 函数。函数 cprstr 的形参为两个字符指针变量。pss

指向源字符串，pds 指向目标字符串。注意表达式：(*pds=*pss)!=`\0'的用法。

cpystr(char *pss,char *pds){

while((*pds=*pss)!='\0'){

pds++;

pss++; }

main(){

char *pa="CHINA",b[10],*pb;

pb=b;

cpystr(pa,pb);

谭浩强 C 语言程序设计 2001 年 5 月 1 日

printf("string a=%s\nstring b=%s\n",pa,pb);

在本例中，程序完成了两项工作：一是把 pss 指向的源字符串复制到 pds 所指向的目标

字符串中，二是判断所复制的字符是否为`\0'，若是则表明源字符串结束，不再循环。否则，

pds 和 pss 都加 1，指向下一字符。在主函数中，以指针变量 pa,pb 为实参，分别取得确定

值后调用 cprstr 函数。由于采用的指针变量 pa 和 pss,pb 和 pds 均指向同一字符串，因此

在主函数和 cprstr 函数中均可使用这些字符串。也可以把 cprstr 函数简化为以下形式：

cprstr(char *pss,char*pds)

{while ((*pds++=*pss++)!=`\0');}

即把指针的移动和赋值合并在一个语句中。 进一步分析还可发现`\0'的 ASCⅡ码为 0，

对于 while 语句只看表达式的值为非 0 就循环，为 0 则结束循环，因此也可省去“!=`\0'”

这一判断部分，而写为以下形式：

cprstr (char *pss,char *pds)

{while (*pdss++=*pss++);}

表达式的意义可解释为，源字符向目标字符赋值，移动指针，若所赋值为非 0 则循环，

否则结束循环。这样使程序更加简洁。

【例 10.30】简化后的程序如下所示。

cpystr(char *pss,char *pds){

while(*pds++=*pss++);

main(){

char *pa="CHINA",b[10],*pb;

pb=b;

cpystr(pa,pb);

printf("string a=%s\nstring b=%s\n",pa,pb);

10.4.2 使用字符串指针变量与字符数组的区别

用字符数组和字符指针变量都可实现字符串的存储和运算。但是两者是有区别的。在使

用时应注意以下几个问题：

1. 字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放

在以该首地址为首的一块连续的内存空间中并以‘\0’作为串的结束。字符数组是

谭浩强 C 语言程序设计 2001 年 5 月 1 日

由于若­干­个数组元素组成的，它可用来存放整个字符串。

2. 对字符串指针方式

char *ps="C Language";

可以写为：

char *ps;

ps="C Language";

而对数组方式：

static char st[]={"C Language"};

不能写为：

char st[20];

st={"C Language"};

而只能对字符数组的各元素逐个赋值。

从以上几点可以看出字符串指针变量与字符数组在使用时的区别，同时也可看出使用

指针变量更加方便。

前面说过，当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对

指针变量直接赋值是可以的。因为 C 系统对指针变量赋值时要给以确定的地址。

因此，

char *ps="C Langage";

或者

char *ps;

ps="C Language";

都是合法的。

10.5 函数指针变量

在Ｃ语言中，一个函数总是占用一段连续的内存区，而函数名就是该函数所占内存区的

首地址。我们可以把函数的这个首地址(或称入口地址)赋予一个指针变量，使该指针变量指

向该函数。然后通过指针变量就可以找到并调用这个函数。我们把这种指向函数的指针变量

称为“函数指针变量”。

函数指针变量定义的一般形式为：

类型说明符 (*指针变量名)();

其中“类型说明符”表示被指函数的返回值的类型。“(* 指针变量名)”表示“*”后面的变量

是定义的指针变量。最后的空括号表示指针变量所指的是一个函数。

例如：

int (*pf)();

表示 pf 是一个指向函数入口的指针变量，该函数的返回值(函数值)是整型。

【例 10.31】本例用来说明用指针形式实现对函数调用的方法。

int max(int a,int b){

if(a>b)return a;

else return b;

main(){

int max(int a,int b);

int(*pmax)();

int x,y,z;

pmax=max;

printf("input two numbers:\n");

scanf("%d%d",&x,&y);

z=(*pmax)(x,y);

printf("maxmum=%d",z);

谭浩强 C 语言程序设计 2001 年 5 月 1 日

从上述程序可以看出用，函数指针变量形式调用函数的步骤如下：

1) 先定义函数指针变量，如后一程序中第 9 行 int (*pmax)();定义 pmax 为函数指针变

量。

2) 把被调函数的入口地址(函数名)赋予该函数指针变量，如程序中第 11 行 pmax=max;

3) 用函数指针变量形式调用函数，如程序第 14 行 z=(*pmax)(x,y);

4) 调用函数的一般形式为：

(*指针变量名) (实参表)

使用函数指针变量还应注意以下两点：

a) 函数指针变量不能进行算术运算，这是与数组指针变量不同的。数组指针变量加减一个

整数可使指针移动指向后面或前面的数组元素，而函数指针的移动是毫无意义的。

b) 函数调用中"(*指针变量名)"的两边的括号不可少，其中的*不应该理解为求值运算，在

此处它只是一种表示符号。

10.6 指针型函数

前面我们介绍过，所谓函数类型是指函数返回值的类型。在Ｃ语言中允许一个函数的返

回值是一个指针(即地址)，这种返回指针值的函数称为指针型函数。

定义指针型函数的一般形式为：

类型说明符 *函数名(形参表)

…… /*函数体*/

其中函数名之前加了“*”号表明这是一个指针型函数，即返回值是一个指针。类型说明符

表示了返回的指针值所指向的数据类型。

如：

int *ap(int x,int y)

...... /*函数体*/

表示 ap 是一个返回指针值的指针型函数，它返回的指针指向一个整型变量。

【例 10.32】本程序是通过指针函数，输入一个 1～7 之间的整数，输出对应的星期名。

main(){

int i;

char *day_name(int n);

printf("input Day No:\n");

scanf("%d",&i);

if(i<0) exit(1);

谭浩强 C 语言程序设计 2001 年 5 月 1 日

printf("Day No:%2d-->%s\n",i,day_name(i));

char *day_name(int n){

static char *name[]={ "Illegal day",

"Monday",

"Tuesday",

"Wednesday",

"Thursday",

"Friday",

"Saturday",

"Sunday"};

return((n<1||n>7) ? name[0] : name[n]);

本例中定义了一个指针型函数 day_name，它的返回值指向一个字符串。该函数中定义

了一个静态指针数组 name。name 数组初始化赋值为八个字符串，分别表示各个星期名及出

错提示。形参 n 表示与星期名所对应的整数。在主函数中，把输入的整数 i 作为实参，在

printf 语句中调用 day_name 函数并把 i 值传送给形参 n。day_name 函数中的 return 语句

包含一个条件表达式，n 值若大于 7 或小于 1 则把 name[0]指针返回主函数输出出错提示字

符串“Illegal day”。否则返回主函数输出对应的星期名。主函数中的第 7 行是个条件语句，

其语义是，如输入为负数(i<0)则中止程序运行退出程序。exit 是一个库函数，exit(1)表

示发生错误后退出程序，exit(0)表示正常退出。

应该特别注意的是函数指针变量和指针型函数这两者在写法和意义上的区别。如

int(*p)()和 int *p()是两个完全不同的量。

int (*p)()是一个变量说明，说明 p 是一个指向函数入口的指针变量，该函数的返回

值是整型量，(*p)的两边的括号不能少。

int *p()则不是变量说明而是函数说明，说明 p 是一个指针型函数，其返回值是一个

指向整型量的指针，*p 两边没有括号。作为函数说明，在括号内最好写入形式参数，这样

便于与变量说明区别。

对于指针型函数定义，int *p()只是函数头部分，一般还应该有函数体部分。

10.7 指针数组和指向指针的指针

10.7.1 指针数组的概念

一个数组的元素值为指针则是指针数组。 指针数组是一组有序的指针的集合。 指针数

组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。

指针数组说明的一般形式为：

类型说明符 *数组名[数组长度]

其中类型说明符为指针值所指向的变量的类型。

例如：

int *pa[3]

谭浩强 C 语言程序设计 2001 年 5 月 1 日

表示 pa 是一个指针数组，它有三个数组元素，每个元素值都是一个指针，指向整型变量。

【例 10.33】通常可用一个指针数组来指向一个二维数组。指针数组中的每个元素被赋予

二维数组每一行的首地址，因此也可理解为指向一个一维数组。

main(){

int a[3][3]={1,2,3,4,5,6,7,8,9};

int *pa[3]={a[0],a[1],a[2]};

int *p=a[0];

int i;

for(i=0;i<3;i++)

printf("%d,%d,%d\n",a[i][2-i],*a[i],*(*(a+i)+i));

for(i=0;i<3;i++)

printf("%d,%d,%d\n",*pa[i],p[i],*(p+i));

本例程序中，pa 是一个指针数组，三个元素分别指向二维数组 a 的各行。然后用循环

语句输出指定的数组元素。其中*a[i]表示 i 行 0 列元素值；*(*(a+i)+i)表示 i 行 i 列的元

素值；*pa[i]表示 i 行 0 列元素值；由于 p 与 a[0]相同，故 p[i]表示 0 行 i 列的值；*(p+i)

表示 0 行 i 列的值。读者可仔细领会元素值的各种不同的表示方法。

应该注意指针数组和二维数组指针变量的区别。这两者虽然都可用来表示二维数组，但

是其表示方法和意义是不同的。

二维数组指针变量是单个的变量，其一般形式中"(*指针变量名)"两边的括号不可少。

而指针数组类型表示的是多个指针(一组有序指针)在一般形式中"*指针数组名"两边不能有

括号。

例如：

int (*p)[3];

表示一个指向二维数组的指针变量。该二维数组的列数为 3 或分解为一维数组的长度为

3。

int *p[3]

表示 p 是一个指针数组，有三个下标变量 p[0]，p[1]，p[2]均为指针变量。

指针数组也常用来表示一组字符串，这时指针数组的每个元素被赋予一个字符串的首地

址。指向字符串的指针数组的初始化更为简单。例如在例 10.32 中即采用指针数组来表示一

组字符串。其初始化赋值为：

char *name[]={"Illagal day",

"Monday",

"Tuesday",

"Wednesday",

"Thursday",

"Friday",

"Saturday",

"Sunday"};

完 成 这 个 初 始 化 赋 值 之 后 ， name[0] 即 指 向 字 符 串 "Illegal day" ， name[1] 指 向

"Monday"......。

指针数组也可以用作函数参数。

谭浩强 C 语言程序设计 2001 年 5 月 1 日

【例 10.34】指针数组作指针型函数的参数。在本例主函数中，定义了一个指针数组 name，

并对 name 作了初始化赋值。其每个元素都指向一个字符串。然后又以 name 作为实参调用

指针型函数 day_name，在调用时把数组名 name 赋予形参变量 name，输入的整数 i 作为第二

个实参赋予形参 n。在 day_ name 函数中定义了两个指针变量 pp1 和 pp2，pp1 被赋予 name[0]

的值(即*name)，pp2 被赋予 name[n]的值即*(name+ n)。由条件表达式决定返回 pp1 或 pp2

指针给主函数中的指针变量 ps。最后输出 i 和 ps 的值。

main(){

static char *name[]={ "Illegal day",

"Monday",

"Tuesday",

"Wednesday",

"Thursday",

"Friday",

"Saturday",

"Sunday"};

char *ps;

int i;

char *day_name(char *name[],int n);

printf("input Day No:\n");

scanf("%d",&i);

if(i<0) exit(1);

ps=day_name(name,i);

printf("Day No:%2d-->%s\n",i,ps);

char *day_name(char *name[],int n)

char *pp1,*pp2;

pp1=*name;

pp2=*(name+n);

return((n<1||n>7)? pp1:pp2);

【例 10.35】输入 5 个国名并按字母顺序排列后输出。现编程如下：

#include"string.h"

main(){

void sort(char *name[],int n);

void print(char *name[],int n);

static char *name[]={ "CHINA","AMERICA","AUSTRALIA",

"FRANCE","GERMAN"};

int n=5;

sort(name,n);

print(name,n);

void sort(char *name[],int n){

char *pt;

int i,j,k;

for(i=0;i

k=i;

for(j=i+1;j

谭浩强 C 语言程序设计 2001 年 5 月 1 日

if(strcmp(name[k],name[j])>0) k=j;

if(k!=i){

pt=name[i];

name[i]=name[k];

name[k]=pt;

void print(char *name[],int n){

int i;

for (i=0;i

说明：

在以前的例子中采用了普通的排序方法，逐个比较之后交换字符串的位置。交换字符串

的物理位置是通过字符串复制函数完成的。反复的交换将使程序执行的速度很慢，同时由于

各字符串(国名)的长度不同，又增加了存储管理的负担。用指针数组能很好地解决这些问题。

把所有的字符串存放在一个数组中，把这些字符数组的首地址放在一个指针数组中，当需要

交换两个字符串时，只须交换指针数组相应两元素的内容(地址)即可，而不必交换字符串本

身。

本程序定义了两个函数，一个名为 sort 完成排序，其形参为指针数组 name，即为待排

序的各字符串数组的指针。形参 n 为字符串的个数。另一个函数名为 print，用于排序后字

符串的输出，其形参与 sort 的形参相同。主函数 main 中，定义了指针数组 name 并作了初

始化赋值。然后分别调用 sort 函数和 print 函数完成排序和输出。值得说明的是在 sort

函数中，对两个字符串比较，采用了 strcmp 函数，strcmp 函数允许参与比较的字符串以指

针方式出现。name[k]和 name[j]均为指针，因此是合法的。字符串比较后需要交换时，只

交换指针数组元素的值，而不交换具体的字符串，这样将大大减少时间的开销，提高了运行

效率。

10.7.2 指向指针的指针

如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的

指针变量。

在前面已经介绍过，通过指针访问变量称为间接访问。由于指针变量直接指向变量，所

以称为“单级间址”。而如果通过指向指针的指针变量来访问变量则构成“二级间址”。

谭浩强 C 语言程序设计 2001 年 5 月 1 日

从下图可以看到，name 是一个指针数组，它的每一个元素是一个指针型数据，其值为

地址。Name 是一个数据，它的每一个元素都有相应的地址。数组名 name 代表该指针数组的

首地址。name+1 是 mane[i]的地址。name+1 就是指向指针型数据的指针（地址）。还可以设

置一个指针变量 p，使它指向指针数组元素。P 就是指向指针型数据的指针变量。

怎样定义一个指向指针型数据的指针变量呢？如下：

char **p;

p 前面有两个*号,相当于*(*p)。显然*p 是指针变量的定义形式，如果没有最前面的*，那就

是定义了一个指向字符数据的指针变量。现在它前面又有一个*号，表示指针变量 p 是指向

一个字符指针型变量的。*p 就是 p 所指向的另一个指针变量。

从下图可以看到，name 是一个指针数组，它的每一个元素是一个指针型数据，其值为

地址。name 是一个数组，它的每一个元素都有相应的地址。数组名 name 代表该指针数组

的首地址。name+1 是 mane[i]的地址。name+1 就是指向指针型数据的指针（地址）。还可以

设置一个指针变量 p，使它指向指针数组元素。P 就是指向指针型数据的指针变量。

如果有：

p=name+2;

printf(“%o\n”,*p);

printf(“%s\n”,*p);

则，第一个 printf 函数语句输出 name[2]的值（它是一个地址），第二个 printf 函数语句

以字符串形式（%s）输出字符串“Great Wall”。

【例 10.36】使用指向指针的指针。

main()

{char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","computer desighn"};

char **p;

int i;

for(i=0;i<5;i++)

{p=name+i;

printf("%s\n",*p);

说明：

p 是指向指针的指针变量。

谭浩强 C 语言程序设计 2001 年 5 月 1 日

【例 10.37】一个指针数组的元素指向数据的简单例子。

main()

{static int a[5]={1,3,5,7,9};

int *num[5]={&a[0],&a[1],&a[2],&a[3],&a[4]};

int **p,i;

p=num;

for(i=0;i<5;i++)

{printf("%d\t",**p);p++;}

说明：

指针数组的元素只能存放地址。

10.7.3 main 函数的参数

前面介绍的 main 函数都是不带参数的。因此 main 后的括号都是空括号。实际上，main

函数可以带参数，这个参数可以认为是 main 函数的形式参数。Ｃ语言规定 main 函数的参

数只能有两个，习惯上这两个参数写为 argc 和 argv。因此，main 函数的函数头可写为：

main (argc,argv)

Ｃ语言还规定 argc(第一个形参)必须是整型变量,argv( 第二个形参)必须是指向字符串的

指针数组。加上形参说明后，main 函数的函数头应写为：

main (int argc,char *argv[])

由于 main 函数不能被其它函数调用，因此不可能在程序内部取得实际值。那么，在何

处把实参值赋予 main 函数的形参呢? 实际上,main 函数的参数值是从­操­作系统命令行上获

得的。当我们要运行一个可执行文件时，在 DOS 提示符下键入文件名，再输入实际参数即可

把这些实参传送到 main 的形参中去。

DOS 提示符下命令行的一般形式为：

C:\>可执行文件名 参数 参数……;

但是应该特别注意的是，main 的两个形参和命令行中的参数在位置上不是一一对应的。

因为,main 的形参只有二个，而命令行中的参数个数原则上未加限制。argc 参数表示了命令

行中参数的个数(注意：文件名本身也算一个参数)，argc 的值是在输入命令行时由系统按

实际参数的个数自动赋予的。

例如有命令行为：

C:\>E24 BASIC foxpro FORTRAN

由于文件名 E24 本身也算一个参数，所以共有 4 个参数，因此 argc 取得的值为 4。argv 参

数是字符串指针数组，其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。 指

谭浩强 C 语言程序设计 2001 年 5 月 1 日

针数组的长度即为参数个数。数组元素初值由系统自动赋予。其表示如图所示：

【例 10.38】

main(int argc,char *argv){

while(argc-->1)

printf("%s\n",*++argv);

本例是显示命令行中输入的参数。如果上例的可执行文件名为 e24.exe，存放在 A 驱动

器的盘内。因此输入的命令行为：

C:\>a:e24 BASIC foxpro FORTRAN

则运行结果为：

BASIC

foxpro

FORTRAN

该行共有 4 个参数，执行 main 时，argc 的初值即为 4。argv 的 4 个元素分为 4 个字符

串的首地址。执行 while 语句，每循环一次 argv 值减 1，当 argv 等于 1 时停止循环，共循

环三次，因此共可输出三个参数。在 printf 函数中，由于打印项*++argv 是先加 1 再打印，

故第一次打印的是 argv[1]所指的字符串 BASIC。第二、三次循环分别打印后二个字符串。

而参数 e24 是文件名，不必输出。

10.8 有关指针的数据类型和指针运算的小结

10.8.1 有关指针的数据类型的小结

定义

int i;

int *p

int a[n];

int *p[n];

int (*p)[n];

int f();

int *p();

int (*p)();

int **p;

含 义

定义整型变量 i

p 为指向整型数据的指针变量

定义整型数组 a，它有 n 个元素

定义指针数组 p，它由 n 个指向整型数据的指针元素组成

p 为指向含 n 个元素的一维数组的指针变量

f 为带回整型函数值的函数

p 为带回一个指针的函数，该指针指向整型数据

p 为指向函数的指针，该函数返回一个整型值

P 是一个指针变量，它指向一个指向整型数据的指针变量

10.8.2 指针运算的小结

现把全部指针运算列出如下：

1) 指针变量加（减）一个整数：

谭浩强 C 语言程序设计 2001 年 5 月 1 日

例如：p++、p--、p+i、p-i、p+=i、p-=i

一个指针变量加（减）一个整数并不是简单地将原值加（减）一个整数，而是将该指针

变量的原值（是一个地址）和它指向的变量所占用的内存单元字节数加（减）。

2) 指针变量赋值：将一个变量的地址赋给一个指针变量。

p=&a; (将变量 a 的地址赋给 p)

p=array; (将数组 array 的首地址赋给 p)

p=&array[i]; (将数组 array 第 i 个元素的地址赋给 p)

p=max; (max 为已定义的函数，将 max 的入口地址赋给 p)

p1=p2; (p1 和 p2 都是指针变量，将 p2 的值赋给 p1)

注意：不能如下：

p=1000;

3) 指针变量可以有空值，即该指针变量不指向任何变量：

p=NULL;

4) 两个指针变量可以相减：如果两个指针变量指向同一个数组的元素，则两个指针变量值

之差是两个指针之间的元素个数。

5) 两个指针变量比较：如果两个指针变量指向同一个数组的元素，则两个指针变量可以进

行比较。指向前面的元素的指针变量“小于” 指向后面的元素的指针变量。

10.8.3 void 指针类型

ANSI 新标准增加了一种“void”指针类型，即可以定义一个指针变量，但不指定它是指向

哪一种类型数据。

11 结构体与共用体

11.1 定义一个结构的一般形式

在实际问题中，一组数据往往具有不同的数据类型。例如，在学生登记表中，姓名应为

字符型；学号可为整型或字符型；年龄应为整型；­性­别应为字符型；成绩可为整型或实型。 显

然不能用一个数组来存放这一组数据。因为数组中各元素的类型和长度都必须一致，以便于

编 译 系 统 处 理 。 为 了 解 决 这 个 问 题 ， Ｃ 语 言 中 给 出 了 另 一 种 构 造 数 据 类 型 ——“ 结 构

（structure）”或叫“结构体”。 它相当于其它高级语言中的记录。“结构”是一种构造类型，

它是由若­干­“成员”组成的。每一个成员可以是一个基本数据类型或者又是一个构造类型。结

构既是一种“构造”而成的数据类型，那么在说明和使用之前必须先定义它，也就是构造它。

如同在说明和调用函数之前要先定义函数一样。

定义一个结构的一般形式为：

struct 结构名

{成员表列};

成员表列由若­干­个成员组成，每个成员都是该结构的一个组成部分。对每个成员也必须

作类型说明，其形式为：

类型说明符 成员名;

成员名的命名应符合标识符的书写规定。例如：

struct stu

int num;

char name[20];

char sex;

float score;

};

在这个结构定义中，结构名为 stu，该结构由 4 个成员组成。第一个成员为 num，整型变

量；第二个成员为 name，字符数组；第三个成员为 sex，字符变量；第四个成员为 score，

实型变量。应注意在括号后的分号是不可少的。结构定义之后，即可进行变量说明。凡说明

为结构 stu 的变量都由上述 4 个成员组成。由此可见， 结构是一种复杂的数据类型，是数目

固定，类型不同的若­干­有序变量的集合。

11.2 结构类型变量的说明

说明结构变量有以下三种方法。以上面定义的 stu 为例来加以说明。

1. 先定义结构，再说明结构变量。

如：

struct stu

int num;

char name[20];

char sex;