C语言教程连载－－第四章 指针、结构、联合和枚举
添加时间: 2007-5-25 7:21:00 作者: 计算机等级考试认证参考 阅读次数:49 来源: http://www.d9soft.com
第四章 指针、结构、联合和枚举
本章专门对第二节曾讲述过的指针作一详述。并介绍Turbo C新的数据类型:结构、联合和枚举, 其中结构和联合是以前讲过的五种基本数据类型(整型、浮点型、字符型、指针型和无值型)的组合。 枚举是一个被命名为整型常数的集合。最后对类型说明(typedef)和预处理指令作一阐述。
指 针(point)
学习Turbo C语言, 如果你不能用指针编写有效、正确和灵活的程序, 可以认为你没有学好C语言。指针、地址、数组及其相互关系是C语言中最有特色的部分。规范地使用指针, 可以使程序达到简单明了, 因此, 我们不但要学会如何正确地使用指针, 而且要学会在各种情况下正确地使用指针变量。
1. 指针和地址
1.1 指针基本概念及其指针变量的定义
1.1.1 指针变量的定义
我们知道变量在计算机内是占有一块存贮区域的, 变量的值就存放在这块区域之中, 在计算机内部, 通过访问或修改这块区域的内容来访问或修改相应的变量。Turbo C语言中, 对于变量的访问形式之一, 就是先求出变量的地址, 然后再通过地址对它进行访问, 这就是这里所要论述的指针及其指针变量。
所谓变量的指针, 实际上指变量的地址。变量的地址虽然在形式上好象类似于整数, 但在概念上不同于以前介绍过的整数, 它属于一种新的数据类型, 即指针类型。Turbo C中, 一般用"指针"来指明这样一个表达式&x的类型, 而用 "地址"作为它的值, 也就是说, 若x为一整型变量, 则表达式&x的类型是指向整数的指针, 而它的值是变量x的地址。同样, 若
double d;
则&d的类型是指向以精度数d的指针, 而&d的值是双精度变量d的地址。所以, 指针和地址是用来叙述一个对象的两个方面。虽然&x、&d的值分别是整型变量x 和双精度变量d的地址, 但&x、&d的类型是不同的, 一个是指向整型变量x的指针,而另一个则是指向双精度变量d的指针。在习惯上, 很多情况下指针和地址这两个术语混用了。
我们可以用下述方法来定义一个指针类型的变量。
int *ip;
首先说明了它是一指针类型的变量, 注意在定义中不要漏写符号"*", 否则它为一般的整型变量了。另外, 在定义中的int 表示该指针变量为指向整型数的指针类型的变量, 有时也可称ip为指向整数的指针。ip是一个变量, 它专门存放整型变量的地址。
指针变量的一般定义为:
类型标识符 *标识符;
其中标识符是指针变量的名字, 标识符前加了"*"号, 表示该变量是指针变量, 而最前面的"类型标识符"表示该指针变量所指向的变量的类型。一个指针变量只能指向同一种类型的变量, 也就是讲, 我们不能定义一个指针变量, 既能指向一整型变量又能指向双精度变量。
指针变量在定义中允许带初始化项。如:
int i, *ip=&i;
注意, 这里是用&i对ip初始化, 而不是对*ip初始化。和一般变量一样, 对于外部或静态指针变量在定义中若不带初始化项, 指针变量被初始化为NULL, 它的值为0。Turbo C中规定, 当指针值为零时, 指针不指向任何有效数据, 有时也称指针为空指针。因此, 当调用一个要返回指针的函数(第五节中介绍)时, 常使用返回值为NULL来指示函数调用中某些错误情况的发生。
1.1.2 指针变量的引用
既然在指针变量中只能存放地址, 因此, 在使用中不要将一个整数赋给一指针变量。下面的赋值是不合法的:
int *ip;
ip=100;
假设
int i=200, x;
int *ip;
我们定义了两个整型变量i, x, 还定义了一个指向整型数的指针变量ip。i, x中可存放整数, 而ip中只能存放整型变量的地址。我们可以把i的地址赋给ip:
ip=&i;
此时指针变量ip指向整型变量i, 假设变量i的地址为1800, 这个赋值可形象理解为下图所示的联系。
ip i
┏━━━┓ ┏━━━┓
┃ 1800 ╂──→ ┃ 200 ┃
┗━━━┛ ┗━━━┛
图1. 给指针变量赋值
以后我们便可以通过指针变量ip间接访问变量i, 例如:
x=*ip;
运算符*访问以ip为地址的存贮区域, 而ip中存放的是变量i的地址, 因此, *ip 访问的是地址为1800的存贮区域(因为是整数, 实际上是从1800开始的两个字节), 它就是i所占用的存贮区域, 所以上面的赋值表达式等价于
x=i;
另外, 指针变量和一般变量一样, 存放在它们之中的值是可以改变的, 也就是说可以改变它们的指向, 假设
int i, j, *p1, *p2;
i=’a’;
j=’b’;
p1=&i;
p2=&j;
则建立如下图所示的联系:
p1 i
┏━━━┓ ┏━━━┓
┃ ╂──→ ┃ ’a’ ┃
┗━━━┛ ┗━━━┛
p2 i
┏━━━┓ ┏━━━┓
┃ ╂──→ ┃ ’b’ ┃
┗━━━┛ ┗━━━┛
图2. 赋值运算结果
这时赋值表达式:
p2=p1
就使p2与p1指向同一对象i, 此时*p2就等价于i, 而不是j, 图2.就变成图3.所示:
p1 i
┏━━━┓ ┏━━━┓
┃ ╂──→ ┃ ’a’ ┃
┗━━━┛ ┌→ ┗━━━┛
p2 │ j
┏━━━┓ │ ┏━━━┓
┃ ╂─┘ ┃ ’b’ ┃
┗━━━┛ ┗━━━┛
图3. p2=p1时的情形
如果执行如下表达式:
*p2=*p1;
则表示把p1指向的内容赋给p2所指的区域, 此时图2.就变成图4.所示
p1 i
┏━━━┓ ┏━━━┓
┃ ╂──→ ┃ ’a’ ┃
┗━━━┛ ┗━━━┛
p2 j
┏━━━┓ ┏━━━┓
┃ ╂──→ ┃ ’a’ ┃
┗━━━┛ ┗━━━┛
图4. *p2=*p1时的情形
通过指针访问它所指向的一个变量是以间接访问的形式进行的, 所以比直接访问一个变量要费时间, 而且不直观, 因为通过指针要访问哪一个变量, 取决于指针的值(即指向), 例如"*p2=*p1;"实际上就是"j=i;", 前者不仅速度慢而且目的不明。但由于指针是变量, 我们可以通过改变它们的指向, 以间接访问不同的变量, 这给程序员带来灵活性, 也使程序代码编写得更为简洁和有效。
指针变量可出现在表达式中, 设
int x, y *px=&x;
指针变量px指向整数x, 则*px可出现在x能出现的任何地方。例如:
y=*px+5; /*表示把x的内容加5并赋给y*/
y=++*px; /*px的内容加上1之后赋给y [++*px相当于++(px)]*/
y=*px++; /*相当于y=*px; px++*/
1.2. 地址运算
指针允许的运算方式有:
(1). 指针在一定条件下, 可进行比较, 这里所说的一定条件, 是指两个指针指向同一个对象才有意义, 例如两个指针变量p, q指向同一数组, 则<, >, >=,<=, ==等关系运算符都能正常进行。若p==q为真, 则表示p, q指向数组的同一元素; 若p素的指针 我们定义一个整型数组和一个指向整型的指针变量: a[10], *p; 和前面介绍过的方法相同, 可以使整型指针p指向数组中任何一个元素, 假定给 出赋值运算 此时, p指向数组中的第0号元素, 指针变量p中包含了数组元素a[0] 的 由于数组元素在内存中是连续存放的, 我们就可以通过指针变量p 及其有关运算间接访问数组中的任何一个元素。 数组名是数组的第0号元素的地址, 因此下面两个语句是等价的 a+1为a[1]的地址, a+i就为a[i]的地址。 下面我们用指针给出数组元素的地址和内容的几种表示形式。 p+i和a+i均表示a[i]的地址, 或者讲, 它们均指向数组第i号元素, 即 指向a[i]。 *(p+i)和*(a+i)都表示p+i和a+i所指对象的内容, 即为a[i]。 (3). 指向数组元素的指针, 也可以表示成数组的形式, 也就是说, 它允许 指针变量带下标, 如p[i]与*(p+i)等价。 假若: 则p[2]就相当于*(p+2), 由于p指向a[5], 所以p[2]就相当于a[7]。而p[-3]就相 当于*(p-3), 它表示a[2]。 2.2. 指向二维数组的指针 2.2.1. 二维数组元素的地址 我们定义以下二维数组: {4,5,6,7}, {8,9,10,11}}; a为二维数组名, 此数组有3行4列, 共12个元素。但也可这样来理解, 数组a由三 个元素组成: a[0], a[2]。而它匀中每个元素又是一个一维数组, 且都含 有4个元素 (相当于4列), 例如, a[0]所代表的一维数组所包含的 4 个元素为 a[0][0], a[0][1], a[0][2], a[0][3]。如图5.所示: ┏━━━━┓ a─→ a[0] ┃─→┃0 a[1] ┃─→┃4 ┣━━━━┫ a[2] ┃─→┃8 ┗━━━━┛ 图5. 但从二维数组的角度来看, a代表二维数组的首地址, 当然也可看成是二维 数组第0行的首地址。a+1就代表第1行的首地址, a+2就代表第2行的首地址。如 果此二维数组的首地址为1000, 由于第0行有4个整型元素, 所以a+1为1008, 也就为1016。如图6.所示 a[3][4]="{{0,1,2,3}," a ┏━┳━┳━┳━┓ (1000)─→┃0 ┃1 ┃2 ┃3 a+1 (1008)─→┃4 ┃5 ┃6 ┃7 a+2 ┣━╋━╋━╋━┫ (1016)─→┃8 ┃9 ┃10┃11┃ ┗━┻━┻━┻━┛ 图6. 既然我们把a[0], a[2]看成是一维数组名, 可以认为它们分别代表它 们所对应的数组的首地址, 也就是讲, a[0]代表第 行中第 0 列元素的地址, 即&a[0][0], a[1]是第1行中第0列元素的地址, 即&a[1][0], a[0]+1即代表第0行第1列元素的地址, 即&a[0][1], 一般而言, a[i]+j即代表第 i行第j列元素的地址, 即&a[i][j]。 在二维数组中, 我们还可用指针的形式来表示各元素的地址。如前所 述, a[0]与*(a+0)等价, a[1]与*(a+1)等价, 因此a[i]+j就与*(a+i)+j等价, 它 表示数组元素a[i][j]的地址。 因此, 二维数组元素a[i][j]可表示成*(a[i]+j)或*(*(a+i)+j), 它们都与 a[i][j]等价, 或者还可写成(*(a+i))[j]。 另外, 要补充说明一下, 如果你编写一个程序输出打印a和*a, 你可发现它 们的值是相同的, 这是为什么呢? 我们可这样来理解: 首先, 为了说明问题, 我 们把二维数组人为地看成由三个数组元素a[0], a[2]组成, 将a[0], a[2]看成是数组名它们又分别是由4个元素组成的一维数组。因此, a表示数组第 0行的地址, 而*a即为a[0], 它是数组名, 当然还是地址, 它就是数组第0 行第0 列元素的地址。 2.2.2 指向一个由n个元素所组成的数组指针 在Turbo C中, 可定义如下的指针变量: (*p)[3]; 指针p为指向一个由3个元素所组成的整型数组指针。在定义中, 圆括号是不 能少的, 否则它是指针数组, 这将在后面介绍。这种数组的指针不同于前面介绍 的整型指针, 当整型指针指向一个整型数组的元素时, 进行指针(地址)加1运算, 表示指向数组的下一个元素, 此时地址值增加了2(因为放大因子为2), 而如上所 定义的指向一个由3个元素组成的数组指针, 进行地址加1运算时, 其地址值增加 了6(放大因子为2x3="6)," 这种数组指针在Turbo C中用得较少, 但在处理二维数 组时, 还是很方便的。例如: a[3][4], (*p)[4]; p="&a[0];" 开始时p指向二维数组第0行, 当进行p+1运算时, 根据地址运算规则, 此时 放大因子为4x2="8," 所以此时正好指向二维数组的第1行。和二维数组元素地址计 算的规则一样, *p+1指向a[0][1], *(p+i)+j则指向数组元素a[i][j]。 例1 a[3] [4]="{" {1,3,5,7}, {9,11,13,15}, {17,19,21,23} main() i,(*b)[4]; b指向二维数组的第1行, 此时*b[0]或 **b是a[1][0] for(i="1;i<=4;b=b[0]+2,i++)/*" 每次增加2 printf(?%d ?,*b[0]); printf(? ?); for (i="0;" i<2; i++) b="a+1;" 修改b的指向, 每次跳过二维数组的 一行 * printf(?%d ?,*(b[i]+1)); printf (? ?); } 程序运行结果如下: 9 13 17 21 3 11 19 3. 字符指针 我们已经知道, 字符串常量是由双引号括起来的字符序列, ?a string? 就是一个字符串常量, 该字符串中因为字符a后面还有一个空格字符, 所以它由8 个字符序列组成。在程序中如出现字符串常量C 编译程序就给字符串常量按排一 存贮区域, 这个区域是静态的, 在整个程序运行的过程中始终占用, 平时所讲的 字符串常量的长度是指该字符串的字符个数, 但在按排存贮区域时, C 编译程序 还自动给该字符串序列的末尾加上一个空字符??, 用来标志字符串的结束, 因 此一个字符串常量所占的存贮区域的字节数总比它的字符个数多一个字节。 Turbo C中操作一个字符串常量的方法有: (1). 把字符串常量存放在一个字符数组之中, s[]="a string" 数组s共有9个元素所组成, 其中s[8]中的内容是??。实际上, 在字符数组定义 的过程中, 编译程序直接把字符串复写到数组中, 即对数组s初始化。 (2). 用字符指针指向字符串, 然后通过字符指针来访问字符串存贮区域。 当字符串常量在表达式中出现时, 根据数组的类型转换规则, 它被转换成字符指 针。因此, 若我们定义了一字符指针cp: *cp; 于是可用: ; 使cp指向字符串常量中的第0号字符a, 如图7.所示。 cp="a string" ┏━━━┓ ┏━┳━┳━┳━┳━┳━┳━┳━┳━┓ ─╂─→ ┃a ┃ ┃s ┃t ┃r ┃i ┃n ┃g ┃┃ ┗━━━┛ ┗━┻━┻━┻━┻━┻━┻━┻━┻━┛ 图7. 以后我们可通过cp来访问这一存贮区域, 如*cp或cp[0]就是字符a, 而cp[i]或 *(cp+i)就相当于字符串的第i号字符, 但企图通过指针来修改字符串常量的行为 是没有意义的。 4. 因为指针是变量, 因此可设想用指向同一数据类型的指针来构成一个数组, 这就是指针数组。数组中的每个元素都是指针变量, 根据数组的定义, 指针数组 中每个元素都为指向同一数据类型的指针。指针数组的定义格式为: 类型标识 *数组名[整型常量表达式]; 例如: int *a[10]; 定义了一个指针数组, 数组中的每个元素都是指向整型量的指针, 该数组由10个 元素组成, 即a[0], a[1], a[2], ..., a[9], 它们均为指针变量。a为该指针数 组名, 和数组一样, a是常量, 不能对它进行增量运算。a为指针数组元素a[0]的 地址, a+i为a[i]的地址, *a就是a[0], *(a+i)就是a[i]。 为什么要定义和使用指针数组呢? 主要是由于指针数组对处理字符串提供了 更大的方便和灵活, 使用二维数组对处理长度不等的正文效率低, 而指针数组由 于其中每个元素都为指针变量, 因此通过地址运算来操作正文行是十分方便的。 指针数组和一般数组一样, 允许指针数组在定义时初始化, 但由于指针数组 的每个元素是指针变量, 它只能存放地址, 所以对指向字符串的指针数组在说明 赋初值时, 是把存放字符串的首地址赋给指针数组的对应元素, 例如下面是一个 书写函数month_name(n), 此函数返回一个指向包含第n月名字的字符指针( 关于 函数, 第6节将专门介绍)。 例2: 打印1月至12月的月名: *month_name(int n) { static char *name[]="{" ?Illegal month?, ?January?, ?February?, ?March?, ?April?, ?May?, ?June?, ?July?, ?August?, ?September?, ?October?, ?November?, ?December? }; return((n<1n>12)?name[0]:name[n]); #p#
}
main()
{
int i;
for(i=0; i<13; i++)
printf("%s ", month_name(i));
}
结 构(struct)
结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。结构中可以使用不同的数据类型。
1. 结构说明和结构变量定义
在Turbo C中, 结构也是一种数据类型, 可以使用结构变量, 因此, 象其它类型的变量一样, 在使用结构变量时要先对其定义。
定义结构变量的一般格式为:
struct 结构名
{
类型 变量名;
类型 变量名;
...
} 结构变量;
结构名是结构的标识符不是变量名。
类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和无值型)。
构成结构的每一个类型变量称为结构成员, 它象数组的元素一样, 但数组中元素是以下标来访问的, 而结构是按变量名字来访问成员的。
下面举一个例子来说明怎样定义结构变量。
struct string
{
char name[8];
int age;
char sex[2];
char depart[20];
float wage1, wage2, wage3, wage4, wage5;
} person;
这个例子定义了一个结构名为string的结构变量person, 如果省略变量名person, 则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义时上例变成:
struct string
{
char name[8];
int age;
char sex[2];
char depart[20];
float wage1, wage2, wage3, wage4, wage5;
};
struct string person;
如果需要定义多个具有相同形式的结构变量时用这种方法比较方便, 它先作 #p#结构说明, 再用结构名来定义变量。
例如:
struct string Tianyr, Liuqi, ...;
如果省略结构名, 则称之为无名结构, 这种情况常常出现在函数内部, 用这种结构时前面的例子变成:
struct
{
char name[8];
int age;
char sex[2];
char depart[20];
float wage1, wage2, wage3, wage4, wage5;
} Tianyr, Liuqi;
2. 结构变量的使用
结构是一个新的数据类型, 因此结构变量也可以象其它类型的变量一样赋值、运算, 不同的是结构变量以成员作为基本变量。
结构成员的表示方式为:
结构变量.成员名
如果将"结构变量.成员名"看成一个整体, 则这个整体的数据类型与结构中该成员的数据类型相同, 这样就可象前面所讲的变量那样使用。
下面这个例子定义了一个结构变量, 其中每个成员都从键盘接收数据, 然后对结构中的浮点数求和, 并显示运算结果, 同时将数据以文本方式存入一个名为age.dat的磁盘文件中。请注意这个例子中不同结构成员的访问。
例3:
#include
main()
{
struct{ /*定义一个结构变量*/
char name[8];
int age;
char sex[2];
char depart[20];
float wage1, wage2, wage3, wage4, wage5;
}a;
FILE *fp;
float wage;
char c=’Y’;
fp=fopen("wage.dat", "w"); /*创建一个文件只写*/
while(c==’Y’c==’y’) /*判断是否继续循环*/
{
printf(" Name:"); #p#
scanf("%s", a.name); /*输入姓名*/
printf("Age:");
scanf("%d", &a.wage); /*输入年龄*/
printf("Sex:");
scanf("%d", a.sex);
printf("Dept:");
; scanf("%s", a.depart);
printf("Wage1:");
scanf("%f", &a.wage1); /*输入工资*/
printf("Wage2:");
scanf("%f", &a.wage2);
printf("Wage3:");
scanf("%f", &a.wage3);
printf("Wage4:");
scanf("%f", &a.wage4);
printf("Wage5:");
scanf("%f", &a.wage5);
wage=a.wage1+a.wage2+a.wage3+a.wage4+a.wage5;
printf("The sum of wage is %6.2f ", wage);/*显示结果*/
fprintf(fp, "%10s%4d%4s%30s%10.2f ", /*结果写入文件*/
a.name, a.age, a.sex, a.depart, wage);
while(1)
{
printf("Continue?"); #p#
c=getche();
if(c==’Y’c==’y’c==’N’c==’n’)
break;
}
}
fclose(fp);
}
3. 结构数组和结构指针
结构是一种新的数据类型, 同样可以有结构数组和结构指针。
一、结构数组
结构数组就是具有相同结构类型的变量集合。假如要定义一个班级40个同学的姓名、性别、年龄和住址, 可以定义成一个结构数组。如下所示:
struct{
char name[8];
char sex[2];
int age;
char addr[40];
}student[40];
也可定义为:
struct string{
char name[8];
char sex[2];
int age;
char addr[40];
};
struct string student[40];
需要指出的是结构数组成员的访问是以数组元素为结构变量的, 其形式为:
结构数组元素.成员名
例如:
student[0].name
student[30].age
实际上结构数组相当于一个二维构造, 第一维是结构数组元素, 每个元素是一个结构变量, 第二维是结构成员。
注意:
结构数组的成员也可以是数组变量。
例如:
struct a
{
int m[3][5];
float f;
char s[20];
}y[4];
为了访问结构a中结构变量y[2]的这个变量, 可写成
y[2].m[1][4]
二、结构指针
结构指针是指向结构的指针。它由一个加在结构变量名前的"*" 操作符来定义, 例如用前面已说明的结构定义一个结构指针如下:
struct string{ #p#
char name[8];
char sex[2];
int age;
char addr[40];
}*student;
也可省略结构指针名只作结构说明, 然后再用下面的语句定义结构指针。
struct string *student;
使用结构指针对结构成员的访问, 与结构变量对结构成员的访问在表达方式上有所不同。结构指针对结构成员的访问表示为:
结构指针名->结构成员
其中"->"是两个符号"-"和">"的组合, 好象一个箭头指向结构成员。例如要给上面定义的结构中name和age赋值, 可以用下面语句:
strcpy(student->name, "Lu G.C");
student->age=18;
实际上, student->name就是(*student).name的缩写形式。
需要指出的是结构指针是指向结构的一个指针, 即结构中第一个成员的首地址, 因此在使用之前应该对结构指针初始化, 即分配整个结构长度的字节空间, 这可用下面函数完成, 仍以上例来说明如下:
student=(struct string*)malloc(size of (struct string));
size of (struct string)自动求取string结构的字节长度, malloc() 函数<BR>定义了一个大小为结构长度的内存区域, 然后将其诈地址作为结构指针返回。
注意:
1. 结构作为一种数据类型, 因此定义的结构变量或结构指针变量同样有局部变量和全程变量, 视定义的位置而定。
2. 结构变量名不是指向该结构的地址, 这与数组名的含义不同, 因此若需要求结构中第一个成员的首地址应该是&[结构变量名]。
4. 结构的复杂形式
一、嵌套结构
嵌套结构是指在一个结构成员中可以包括其它一个结构, Turbo C 允许这种嵌套。
例如: 下面是一个有嵌套的结构
struct string{
char name[8];
int age;
struct addr address;
} student;
其中: addr为另一个结构的结构名, 必须要先进行, 说明, 即
struct addr{
char city[20];
unsigned lon zipcode;
char tel[14];
}
如果要给student结构中成员address结构中的zipcode赋值, 则可写成:
student.address.zipcode=200001;
每个结构成员名从最外层直到最内层逐个被列出, 即嵌套式结构成员的表达 #p时, 实际参数会代替这些形式参数。
例如:
#define MAX(x, y) (x>y)?x:y
main()
{
int i=10, j=15;
printf("The Maxmum is %d", MAX(i, j);
}
上例宏定义语句的含义是用宏替换名MAX(x, y)代替x, y中较大者, 同样也可定义:
#define MIN(x, y) (x
程序也允许嵌入其它文件, 例如:
main()
{
#include
, }
其中help.c为另一个文件, 内容可为
printf("Glad to meet you here!");
上例编译时将按集成开发环境的Options/Directories/Include directories中指定的包含文件路径查找被嵌入文件。
4. #if、#else、#endif指令
#if、#els和#endif指令为条件编择指令, 它的一般形式为:
#if 常数表达式
语句段;
#else
语句段;
#endif
上述结构的含义是: 若#if指令后的常数表达式为真, 则编译#if到#else 之间的程序段; 否则编译#else到#endif之间的程序段。
例如:
#define MAX 200
main()
{
#if MAX>999
printf("compiled for bigger ");
#else
printf("compiled for small ");
#endif
}
5. #undef指令
#undef指令用来删除事先定义的宏定义, 其一般形式为:
#undef 宏替换名
例如:
#define TRUE 1
...
#undef TURE
#undef主要用来使宏替换名只限定在需要使用它们的程序段中。
上一篇文章: C语言教程：第六章:指针（5） 下一篇文章: C语言教程：第五章:函数（4）
相关文章: