tc续...
时间：2005-11-14 来源：我菜我怕谁
其中: 上面的?分别为:
T Tiny(微型模式)
S Small(小模式)
C Compact(紧凑模式)
M Medium(中型模式)
L Large(大模式)
H Huge(巨大模式)
T Tiny(微型模式)
S Small(小模式)
C Compact(紧凑模式)
M Medium(中型模式)
L Large(大模式)
H Huge(巨大模式)
4. 变量
4.1 变量说明
Turbo C2.0规定所有变量在使用前都必须中以说明。一条变量说明语句由数据
类型和其后的一个或多个变量名组成。变量说明的形式如下:
类型 <变量表>;
这里类型是指Turbo C2.0的有效数据类型。变量表是一个或多个标识符名, 每
个标识符之间用","分隔。
例如:
int i, j, k; unsigned char c, str[5], *p;
4.2 变量种类
变量可以在程序中三个地方说明: 函数内部、函数的参数定义中或所有的函数
外部。根据所定义位置的不同, 变量可分为局部变量、形式参数和全程变量。
一、局部变量
局部变量是指在函数内部说明的变量(有时也称为自动变量)。用关键字auto进
行说明, 当auto省略时, 所有的非全程变量都被认为是局部变量, 所以auto实际上
从来不用。
局部变量在函数调用时自动产生, 但不会自动初始化, 随函数调用的结束, 这
个变量也就自动消失了, 下次调用此函数时再自动产生, 还要再赋值, 退出时又自
动消失。
二、形式参数
形式参数是指在函数名后面的小括号里定义的变量, 用于接受来自调用函数的
参数。形式参数在函数内部可以象其它局部变量那样来作用。
例如:
puthz(int x, int y, int color, char *p)
{
int i, j, k; /*定义局部变量*/
<程序体>
}
其中x, y, color, *p为函数的形式参数, 不需要再进行说明就可在该函数内
直使用。
三、全程变量
全程变量是指在所有函数之外说明的变量, 它在整个程序内部者是"可见的",
可以被任何一个函数使用, 并且在整个程序的运行中都保留其值。全程变量只要满
足在使用它以前和函数以外这两个条件, 可在程序的任何位置进行说明, 习惯上通
常在程序的主函数前说明。
例如:
#include<stdio.h>
int test; /*定义全程变量*/
void f1(int x, float y); /*子函数说明*/
void f2(void); /*子函数说明*/
main()
{
test=5; /*给全程变量赋值*/
f1(20, 5.5); /*调用有形式参数的子函数f1()*/
/*test的值变成115*/
f2(); /*调用f2(), test的值变为1150*/
}
void f1(int x, float y)
{
float z; /*z定义为局部变量*/
z=x*y; /*计算*/
test=test+z;
}
void f2(void)
{
int count=10; /*定义局部变量并初始化*/
test=test*count;
}
由于全程变量可被整个程序内的任何一个函数使用, 所以可作为函数之间传递
参数的手段, 但全程变量太多时, 内存开销变大。
4.3 变量存储类型
Turbo C2.0支持四种变量存储类型。说明符如下:
auto static extern register
下面分别来介绍。
一、auto
auto称为自动变量, 已在前面作了介绍, 这里不再重复。
二、static
static称为静态变量。根据变量的类型可以分为静态局部变量和静态全程变量。
1. 静态局部变量
它与局部变量的区别在于: 在函数退出时, 这个变量始终存在, 但不能被其它
函数使用, 当再次进入该函数时, 将保存上次的结果。其它与局部变量一样。
2. 静态全程变量
Turbo C2.0允许将大型程序分成若干独立模块文件分别编译, 然后将所有模块
的目标文件连接在一起, 从而提高编译速度, 同时也便于软件的管理和维护。静态
全程变量就是指只在定义它的源文件中可见而在其它源文件中不可见的变量。它与
全程变量的区别是: 全程变量可以再说明为外部变量(extern), 被其它源文件使用,
而静态全程变量却不能再被说明为外部的, 即只能被所在的源文件使用。
三、extern
extern称为外部变量。为了使变量除了在定义它的源文件中可以使用外, 还要
被其它文件使用。因此, 必须将全程变量通知每一个程序模块文件, 此时可用
extern来说明。
例如:
文件1为file1.c 文件2为file2.c
int i, j;/*定义全程变量*/ extern int i, j;/*说明将i, j从
文件1中复制过来*/
char c; extern char c; /*将c复制过来*/
void func1(int k); func2() /*用户定义函数*/
{
main() static float k;/*定义静态变量*/
{ i=j*5/100;
func1(20);/*调用函数*/ k=i/1.5;
func2(); .
. .
. .
. }
}
func1(int k) /*用户定义函数*/
{
j=k*100;
}
对于以上两个文件file1.c和file2.c, 用Turbo C2.0的集成开发环境进行编译
连接时, 首先应建立一个.prj的文件。例如file.prj, 该文件内容如下:
file1.c
file2.c
然后将file.prj的文件名写入主菜单Project中的Project Name项中。 再用F9
编译连接, 就可产生一个文件名为fioe.exe的可执行文件。
外部变量和FORTRAN语言中的COMMOM定义的公共变量一样。
四、register
register称为寄存器变量。它只能用于整型和字符型变量。定义符register说
明的变量被Turbo C2.0存储在CPU的寄存器中, 而不是象普通的变量那样存储在内
存中, 这样可以提高运算速度。但是Turbo C2.0只允许同时定义两个寄存器变量,
一旦超过两个, 编译程序会自动地将超过限制数目的寄存器变量当作非寄存器变量
来处理。因此, 寄存器变量常用在同一变量名频繁出现的地方。
另外, 寄存器变量只适用于局部变量和函数的形式参数, 它属于auto型变量,
因此, 不能用作全程变量。定义一个整型寄存器变量可写成:
register int a;
对于以上所介绍的变量类型和变量存储类型将会在以后的学习中, 通过例行程
序中的定义、使用来逐渐加深理解。
4.4 数组变量
所谓数组就是指具有相同数据类型的变量集, 并拥有共同的名字。数组中的每
个特定元素都使用下标来访问。数组由一段连续的存贮地址构成, 最低的地址对应
于第一个数组元素, 最高的地址对应最后一个数组元素。数组可以是一维的、也可
以是多维的。Turbo C2.0象它高级语方一样也使用数组变量。
一、一维数组
一维数组的说明格式是:
类型 变量名[长度];
类型是指数据类型, 即每一个数组元素的数据类型, 包括整数型、浮点型、字
符型、指针型以及结构和联合。
例如:
int a[10];
unsigned long a[20];
char *s[5];
char *f[];
说明:
1. 数组都是以0作为第一个元素的下标, 因此, 当说明一个int a[16] 的整型
数组时, 表明该数组有16个元素, a[0]~a[15], 一个元素为一个整型变量。
2. 大多数字符串用一维数组表示。数组元素的多少表示字符串长度, 数组名
表示字符串中第一个字符的地址, 例如在语句char str[ 8] 说明的数组中存入
"hello"字符串后, str表示第一个字母"h"所在的内存单元地址。str[0] 存放的是
字母"h"的ASCII码值, 以此类推, str[4]存入的是字母"o"的ASCII码值, str[5]则
应存放字符串终止符''。
3. Turbo C2.0对数组不作边界检查。例如用下面语句说明两个数组
char str1[5], str2[6];
当赋给str1一个字符串"ABCDEFG"时, 只有"ABCDE"被赋给, "E" 将会自动的赋
给str2, 这点应特别注意。
三、多维数组
多维数组的一般说明格式是:
类型 数组名[第n维长度][第n-1维长度]......[第1维长度];
这种说明方式与BASIC、FORTRAN等语言中多维数组的说明不一样。
例如:
int m[3][2]; /*定义一个整数型的二维数组*/
char c[2][2][3]; /*定义一个字符型的三维数组*/
数组m[3][2]共有3*2=6个元素, 顺序为:
m[0][0], m[0][1], m[1][0], m[1][1], m[2][0], m[2][1];
数组c[2][2][3]共有2*2*3=12个元素, 顺序为:
c[0][0][0], c[0][0][1], c[0][0][2],
c[0][1][0], c[0][1][1], c[0][1][2],
c[1][0][0], c[1][0][1], c[1][0][2],
c[1][1][0], c[1][1][1], c[1][1][2],
数组占用的内存空间(即字节数)的计算式为:
字节数=第1维长度*第2维长度*...*第n维长度*该数组数据类型占用的字节数
4.5 变量的初始化和赋值
一、变量的初始化
变量的初始化是指变量在被说明的同时赋给一个初值。Turbo C2.0中外部变量
和静态全程变量在程序开始处被初始化, 局部变量包括静态局部变量是在进入定义
它们的函数或复合语句时才作初始化。所有全程变量在没有明确的初始化时将被自
动清零, 而局部变量和寄存器变量在未赋值前其值是不确定的。
对于外部变量和静态变量, 初值必须是常数表达式, 而自动变量和寄存器变量
可以是任意的表达式, 这个表达式可以包括常数和前面说明过的变量和函数。
1. 单个变量的初始化
例如:
float f0, f1=0.2;/*定义全程变量, 在初始化时f0被清零, f1被赋0.2*/
main()
{
static int i=10, j; /*定义静态局部变量, 初始化时i被赋10, j不确
定*/
int k=i*5; /*定义局部变量, 初始化时k被赋10*5=50*/
char c='y'; /*定义字符型指什变量并初始化*/
.
.
.
}
2. 数组变量的初始化
例如:
main()
{
int p[2][3]={{2, -9, 0}, {8, 2, -5}}; /*定义数组p并初始化/*
int m[2][4]={{27, -5, 19, 3}, {1, 8, -14, -2}};/*定义数组m并初
始化*/
char *f[]={'A', 'B', 'C'}; /*定义数组f并初始化*/
.
.
.
}
从上例可以看出: Turbo C2.0中数组进行初始化有下述规则:
(1) 数组的每一行初始化赋值用"{}"并用","分开, 总的再加一对"{}"括起来,
最后以";"表示结束。
(2) 多维数组的存储是按最右维数的变量变化最快的原则。
(3) 多维数组存储是连续的, 因此可以用一维数组初始化的办法来初始化多维
数组。
例如:
int x[2][3]={1, 2, 3, 4, 5, 6};/*用一维数组来初始化二维数组*/
(4) 对数组初始化时, 如果初值表中的数据个数比数组元素少, 则不足的数组
元素用0来填补。
(5) 对指针型变量数组可以不规定维数, 在初始化赋值时, 数组维数从0 开始
被连续赋值。
例如:
char *f[]={'a', 'b', 'c'};
初始化时将会给3个字符指针赋值, 即: *f[0]='a', *f[1]='b', *f[2]='c'。
3. 指针型变量的初始化
例如:
main()
{
int *i=7899; /*定义整型数指针变量并初始化*/
float *f=3.1415926; /*定义浮点数指针变量并初始化*/
char *s="Good"; /*定义字符型指针变量并初始化*/
.
.
.
}
二、变量的赋值
变量赋值是给已说明的变量赋给一个特定值。
1. 单个变量的赋值
(1) 整型变量和浮点变量
这两种变量采用下列格式赋值
变量名=表达式;
例如:
main()
{
int a, m; /*定义局部整型变量a, m*/
float n; /*定义局部浮点变量f*/
a=100, m=20; /*给变量赋值*/
n=a*m*0.1;
.
.
.
}
说明:
Turbo C2.0中允许给多个变量赋同一值时可用连等的方式。
例如:
main()
{
int a, b, c;
a=b=c=0; /*同时给a,b,c赋值*/
.
.
.
}
(2) 字符型变量
字符型变量可以用三种方法赋值。
例如:
main()
{
char a0, a1, a2; /*定义局部字符型变量a0, a1, a2*/
a0='b'; /*将字母b赋给a0*/
a1=50; /*将数字2(十进制ASCII值为50赋给a1*/
a2='x0d'; /*将回车符赋给a2*/
.
.
.
}
(3) 指针型变量
例如:
main()
{
int *i;
char *str;
*i=100;
str="Good";
.
.
.
}
*i表示i是一个指向整型数的指针, 即*i是一个整型变量, i是一个指向该整型
变量的地址。
*str表示str是一个字符型指针, 即保留某个字符地址。在初始化时, str没有
什么特殊的值, 而在执行str="Good"时, 编译器先在目标文件的某处保留一个空间
存放"Good"的字符串, 然后把这个字符串的第一个字母"G"的地址赋给str, 其中
字符串结尾符""是编译程序自动加上的。
对于指针变量的使用要特别注意。上例中两个指针在说明前没有初始化, 因此
这两指针为随机地址, 在小存储模式下使用将会有破坏机器的危险。正确的使用办
法如下:
例如:
main()
{
int *i;
char *str;
i=(int*)malloc(sizeof(int));
i=420;
str=(char*)malloc(20);
str="Good, Answer!";
.
.
.
}
上例中, 函数(int*)malloc(sizeof(int))表示分配连续的sizeof(int)=2个字
节的整型数存储空间并返回其首地址。同样(char*)malloc(20)表示分配连续20 个
字节的字符存储空间并返回首地址(有关该函数以后再详述)。由动态内存分配函数
malloc()分配了内存空间后, 这部分内存将专供指针变量使用。
如果要使i指向三个整型数, 则用下述方法。
例如:
#include<alloc.h>
main()
{
int *a;
a=(int*)malloc(3*sizeof(int));
*a=1234;
*(a+1)=4567;
*(a+2)=234;
.
.
.
}
*i=1234表示把1234存放到i指向的地址中去, 但对于*(i+1)=4567, 如果认为
将4567存放到i指向的下一个字节中就错了。Turbo C2.0中只要说明i为整型指针,
则 (i+1) 等价于 i+1*sizeof(int)
同样 (i+2) 等价于 i+2*sizeof(int)
2. 数组变量的赋值
(1) 整型数组和浮点数组的赋值
例如:
main()
{
int m[2][2];
float n[3];
m[0][0]=0, m[0][1]=17, m[1][0]=21;/*数组元素赋值*/
n[0]=109.5, n[1]=-8.29, n[2]=0.7;
.
.
.
}
(2)字符串数组的赋值
例如:
main()
{
char s[30];
strcpy(s, "Good News!"); /*给数组赋字符串*/
.
.
.
}
上面程序在编译时, 遇到char s[30]这条语句时, 编译程序会在内存的某处留
出连续30个字节的区域, 并将第一个字节的地址赋给s。当遇到strcpy( strcpy 为
Turbo C2.0的函数)时, 首先在目标文件的某处建立一个"Good News!" 的字符串。
其中表示字符串终止, 终止符是编译时自动加上的, 然后一个字符一个字符地复
制到s所指的内存区域。因此定义字符串数组时, 其元素个数至少应该比字符串的
长度多1。
注意:
1. 字符串数组不能用"="直接赋值, 即s="Good News!"是不合法的。所以应分
清字符串数组和字符串指针的不同赋值方法。
2. 对于长字符串, Turbo C2.0允许使用下述方法:
例如:
main()
{
char s[100];
strcpy(s, "The writer would like to thank you for"
"your interest in his book. He hopes you"
"can get some helps from the book.");
.
.
.
}
(3)指针数组赋值
例如:
main()
{
char *f[2];
int *a[2];
f[0]="thank you"; /*给字符型数组指针变量赋值*/
f[1]="Good Morning";
*a[0]=1, *a[1]=-11; /*给整型数数组指针变量赋值*/
.
.
.
}
三、数组与指针
数组与指针有密切的联系。数组名本身就是该数组的指针, 反过来, 也可以把
指针看成一个数组, 数组名和指针实质上都是地址, 但是指针是变量, 可以作运算。
而数组名是常量, 不能进行运算。
例如:
main()
{
char s[30], *p; /*定义字符型数组和指针变量*/
p=s; /*指针p指向数组s的第一个元素s[0]的地址*/
.
.
.
*(p+8); /*指针p指向数组s的第9个元素s[8]的地址*/
.
.
.
}
由上例可以看出数组和指针有如下关系:
(p+i)=&(s[i])
*(p+i)=s[i]
因此, 利用上述表达式可以对数组和指针进行互换。两者的区别仅在于: 数组
s是程序自动为它分配了所需的存储空间; 而指针p则是利用动态分想函数为它分配
存储空间或赋给它一个已分配的空间地址。
3 关键字和标识符
3.1 关键字
所谓关键字就是已被Turbo C2.0本身使用, 不能作其它用途使用的字。例如关
键字不能用作变量名、函数名等。
Turbo C2.0有以下关键字:
Turbo C2.0扩展的共11个
asm _cs _ds _es _ss cdecl
far near huge interrupt pascal
由ANSI标准定义的共32个
auto double int struct break else
long switch case enum register typedef
char extern return union const float
short unsigned continue for signed void
default goto sizeof volatile do if
while static
3.2 标识符
所谓标识符是指常量、变量、语句标号以及用户自定义函数的名称。 Turbo C
2.0标识符的定义十分灵活。作为标识符必须满足以下规则:
1. 所有标识符必须由一个字母(a~z, A~Z)或下划线(_)开头;
2. 标识符的其它部分可以用字母、下划线或数字(0~9)组成;
3. 大小写字母表示不同意义, 即代表不同的标识符;
4. 标识符只有前32个字符有效;
5. 标识符不能使用Turbo C2.0的关键字。
下面举出几个正确和不正确的标识符:
正确 不正确
smart 5smart
_decision bomb?
key_board key.board
FLOAT float
函数
C程序是由一组或是变量或是函数的外部对象组成的。 函数是一个自我包含的
完成一定相关功能的执行代码段。我们可以把函数看成一个"黑盒子", 你只要将数
据送进去就能得到结果, 而函数内部究竟是如何工作的的, 外部程序是不知道的。
外部程序所知道的仅限于输入给函数什么以及函数输出什么。函数提供了编制程序
的手段, 使之容易读、写、理解、排除错误、修改和维护。
C程序中函数的数目实际上是不限的, 如果说有什么限制的话, 那就是, 一个C
程序中必须至少有一个函数, 而且其中必须有一个并且仅有一个以main为名, 这个
函数称为主函数, 整个程序从这个主函数开始执行。
C 语言程序鼓励和提倡人们把一个大问题划分成一个个子问题, 对应于解决一
个子问题编制一个函数, 因此, C 语言程序一般是由大量的小函数而不是由少量大
函数构成的, 即所谓"小函数构成大程序"。这样的好处是让各部分相互充分独立,
并且任务单一。因而这些充分独立的小模块也可以作为一种固定规格的小"构件",
用来构成新的大程序。
C语言的一个主要特点是可以建立库函数。Turbo C2.0提供的运行程序库有400
多个函数, 每个函数都完成一定的功能, 可由用户随意调用。这些函数总的分为输
入输出函数、数学函数、字符串和内存函数、与BIOS和DOS有关的函数、 字符屏幕
和图形功能函数、过程控制函数、目录函数等。对这些库函数应熟悉其功能, 只有
这样才可省去很多不必要的工作。
本教程后半部分专门介绍Turbo C2.0的库函数, 并对每个函数都给出例程, 读
者可以将自已需要的部分以块的方式定义, 然后将此块写入文件, 这样就可以在进
入Turbo C2.0集成开发环境后, 直接调用此程序, 连接, 运行, 观察结果, 以加深
对该函数的理解。
用户编制Turbo C语言源程序, 就是利用Turbo C的库函数。可以把所有使用的
库函数放在一个庞大的主函数里, 也可以按不同功能设计成一个个用户函数而被其
它函数调用。Turbo C2.0建议用户使用后者, 当用户编制了一些较常用的函数时,
只要将其存在函数库里, 在以后的编程中可被方便的调用而不需要再去编译它们。
连接时将会自动从相应的库中装配成所需程序。
1. 函数的说明与定义
Turbo C2.0中所有函数与变量一样在使用之前必须说明。所谓说明是指说明函
数是什么类型的函数, 一般库函数的说明都包含在相应的头文件<*.h>中, 例如标
准输入输出函数包含在stdio.h中, 非标准输入输出函数包含在io.h中, 以后在使
用库函数时必须先知道该函数包含在什么样的头文件中, 在程序的开头用#include
<*.h>或#include"*.h"说明。只有这样程序在编译, 连接时Turbo C 才知道它是提
供的库函数, 否则, 将认为是用户自己编写的函数而不能装配。
1.1 函数说明
1. 经典方式
其形式为: 函数类型 函数名();
2. ANSI 规定方式
其形式为: 函数类型 函数名(数据类型 形式参数, 数据类型 形式
参数, ......);
其中: 函数类型是该函数返回值的数据类型, 可以是以前介绍的整型(int),
长整型(long), 字符型(char), 单浮点型(float), 双浮点型(double)以及无值型
(void), 也可以是指针, 包括结构指针。无值型表示函数没有返回值。
函数名为Turbo C2.0的标识符, 小括号中的内容为该函数的形式参数说明。可
以只有数据类型而没有形式参数, 也可以两者都有。对于经典的函数说明没有参数
信息。如:
int putlll(int x,int y,int z,int color,char *p)/*说明一个整型函数*/
char *name(void); /*说明一个字符串指什函数*/
void student(int n, char *str); /*说明一个不返回值的函数*/
float calculate(); /*说明一个浮点型函数*/
注意: 如果一个函数没有说明就被调用, 编译程序并不认为出错, 而将此函数
默认为整型(int)函数。因此当一个函数返回其它类型, 又没有事先说明, 编译时
将会出错。
1.2 函数定义
函数定义就是确定该函数完成什么功能以及怎么运行, 相当于其它语言的一个
子程序。Turbo C2.0对函数的定义采用ANSI规定的方式。即:
函数类型 函数名(数据类型形式参数; 数据类型 形式参数...)
{
函数体;
}
其中函数类型和形式参数的数据类型为Turbo C2.0的基本数据类型。函数体为
Turbo C2.0提供的库函数和语句以及其它用户自定义函数调用语句的组合, 并包括
在一对花括号"{"和"}"中。
需要指出的是一个程序必须有一个主函数, 其它用户定义的子函数可以是任意
多个, 这些函数的位置也没有什么限制, 可以在main()函数前, 也可以在其后。
Turbo C2.0将所有函数都被认为是全局性的。而且是外部的, 即可以被另一个文件
中的任何一个函数调用。
2 函数的调用
2.1 函数的简单调用
Turbo C2.0调用函数时直接使用函数名和实参的方法, 也就是将要赋给被调用
函数的参量, 按该函数说明的参数形式传递过去, 然后进入子函数运行, 运行结束
后再按子函数规定的数据类型返回一个值给调用函数。使用Turbo C2.0的库函数就
是函数简单调用的方法。举例说明如下:
例1:
#include<stdio.h>
int maxmum(int x, int y, int z); /*说明一个用户自定义函数*/
int main()
{
int i, j, k;
printf("i, j, k=? ");
scanf("%4d%4d%4d", &i, &j, &k);
maxmum(i, j, k);
getch();
return 0;
}
maxmum(int x, int y, int z)
{
int max;
max=x>y?x:y;
max=max>z?max:z;
printf("The maxmum value of the 3 data is %d ", max);
}
2.2 函数参数传递
一、调用函数向被调用函数以形式参数传递
用户编写的函数一般在对其说明和定义时就规定了形式参数类型, 因此调用这
些函数时参量必须与子函数中形式参数的数据类型、顺序和数量完全相同, 否则在
调用中将会出错, 得到意想不到的结果。
注意:
当数组作为形式参数向被调用函数传递时, 只传递数组的地址, 而不是将整个
数组元素都复制到函数中去, 即用数组名作为实参调用子函数, 调用时指向该数组
第一个元素的指针就被传递给子函数。因为在Turbo C2.0中, 没有下标的数组名就
是一个指向该数组第一个元素的指针。当然数组变量的类型在两个函数中必须相同。
用下述方法传递数组形参。
例2:
#include<stdio.h>
void disp(int *n);
int main()
{
int m[10], i;
for(i=0; i<10; i++)
m[i]=i;
disp(m); /*按指针方式传递数组*/
getch();
return 0;
}
void disp(int *n)
{
int j;
for(j=0; j<10; j++)
printf("%3d", *(n++));
printf(" ");
}
另外, 当传递数组的某个元素时, 数组元素作为实参, 此时按使用其它简单变
量的方法使用数组元素。例2按传递数组元素的方法传递时变为:
#include<stdio.h>
void disp(int n);
int main()
{
int m[10], i;
for(i=0; i<10; i++){
m[i]=i;
disp(m[i]); /*逐个传递数组元素*/
}
getch();
return 0;
}
void disp(int n)
{
printf("%3d ");
}
这时一次只传递了数组的一个元素。
二、被调用函数向调用函数返回值
一般使用return语句由被调用函数向调用函数返回值, 该语句有下列用途:
1. 它能立即从所在的函数中退出, 返回到调用它的程序中去。
2. 返回一个值给调用它的函数。
有两种方法可以终止子函数运行并返回到调用它的函数中: 一是执行到函数的
最后一条语句后返回; 一是执行到语句return时返回。前者当子函数执行完后仅返
回给调用函数一个0。若要返回一个值, 就必须用return语句。只需在return 语句
中指定返回的值即可。例1返回最大值时变为:
例3:
#include<stdio.h>
int maxmum(int x, int y, int z); /*说明一个用户自定义函数*/
int main()
{
int i, j, k, max;
printf("i, j, k=? ");
scanf("%4d%4d%4d", &i, &j, &k);
max=maxmum(i, j, k); /*调用子函数, 并将返回值赋给max*/
printf("The maxmum value is %d ", max);
getch();
return 0;
}
maxmum(int x, int y, int z)
{
int max;
max=x>y?x:y; /*求最大值*/
max=max>z?max:z;
return(max); /*返回最大值*/
}
return语句可以向调用函数返回值, 但这种方法只能返回一个参数, 在许多情
况下要返回多个参数, 这是用return语句就不能满足要求。Turob C2.0提供了另一
种参数传递的方法, 就是调用函数向被调用函数传递的形式参数不是传递变量本身,
而是传递变量的地址, 当子函数中向相应的地址写入不同的数值之后, 也就改变了
调用函数中相应变量的值, 从而达到了返回多个变量的目的。
例4:
#include<stdio.h>
void subfun(int *m, int *n); /*说明子函数*/
int main()
{
int i, j;
printf("i, j=? ");
scanf("%d, %d", &i, &j); /*从键盘输入2个整数*/
printf("In main before calling "/*输出此2数及其乘积*/
"i=%-4d j=%-4d i*j=%-4d ", i, j, i*j);
subfun(&i, &j); /*以传送地址的方式调用子函数*/
printf("In main after calling "/*调用子函数后输出变量值*/
"i=%-4d j=%-4d i*j=%-4d ", i, j, i*j);
getch();
return 0;
}
相关阅读 更多 +
