第七章 函数应用程序设计授课老师,危孟君
Email,weimengjun@163.com
C语言程序设计 (第 2版 )
中南大学出版社成奋华 陈松乔 著内容提要
1、概述
2、函数的定义
3、函数的参数（变量、数组）和函数值
4、函数的调用
5、函数的嵌套调用
6、局部变量、全局变量及变量的存储类型
§ 7.1 概述
C是模块化程序设计语言源程序文件1
预编译命令说明部分 执行部分函数1 函数n
源程序文件i 源程序文件n
C程序
C程序结构?C是 函数式 语言
必须有且只能有一个名为 main的主函数
函数 不能嵌套定义,可以 嵌套 调用
模块化程序设计
基本思想：将一个大的程序按功能分割成一些小模块,
特点：
各模块相对独立、功能单一、结构清晰、接口简单
控制了程序设计的复杂性
提高元件的可靠性
缩短开发周期
避免程序开发的重复劳动
易于维护和功能扩充
开发方法,自上向下，逐步分解，分而治之程序说明
#include <stdio.h>
void star()
{printf(“**********\n”);}
void main()
{
star();
printf (“Hello,World! \n”);
}
1、程序从 main()函数中开始，调用其他的子函数以后，在 main()函数中结束；
2、所有的子函数都是 平行 的，任何子函数都不属于其他函数；
3、从用户的角度来看，函数可以分为：
标准函数，即库函数，如 printf()
自定义函数 如 star()
4、从函数形式来看，可分为：
无参数函数，如 star()
有参数函数，如 printf()。
§ 7.2 函数的定义
一般格式 合法标识符函数返回值类型缺省 int型无返回值 void
函数体函数类型 函数名 （ [形参类型说明表 ]）
{
说明部分语句部分
}
例 有参函数（现代风格）
int max(int x,int y)
{ int z;
z=x>y?x:y;
return(z);
}
例 有参函数（现代风格）
int max(int x,y)
{ int z;
z=x>y?x:y;
return(z);
}
例 空函数
dummy( )
{ }
函数体为空例 无参函数
printstar( )
{ printf(“**********\n”);
或
printstar(void )
{ printf(“**********\n”); }
局部变量：
函数体内定义的变量，其有效范围仅限于所在函数的内部，离开函数体则无意义比如：变量 x,y,z
函数参数和函数的值
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
一个 C程序由若干个函数组成，各函数调用时经常需要传递一些数据，即 调用函数 把参数传递给 被调用函数,经 被调用函数处理后，得到一个确切的结果，
在返回调用函数时，把这个结果带回 调用函数 。
调用函数 被调用函数
…………
c=max(a,b);
…………
int max(int x,int y)
…………
return(z);
a,b
z
函数参数：用于函数间数据的传递；
形式参数,定义 函数时使用的参数；
实际参数,引用 函数时使用的参数；
函数 max有两个形式参数 x,y
参数 x和 y只能在 max中使用
a和 b是主函数中定义的变量
main函数调用函数 max
a和 b为函数 max的实参形式参数和实际参数
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
说明：
1、定义函数时，必须说明形参的类型，形参必须是 变量 或者 数组 ；
2、实参可以是 常量,变量 或者 表达式 ；
3,形参与实参的类型必须一致,字符型和整型可以互相匹配；
4,C语言中，形参对实参的传递是,值传递,，即单向传递。它仅由参数的相对位臵决定，与名字无关。
形式参数和实际参数
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
看程序，写出运行结果
#include <stdio.h>
int sum(int a,int b)
{ a=a+b; b=a+b; return a; }
void main()
{
int a=1,b=3,c;
c=sum(a,b);
printf(“sum of %d,%d is %d\n”,a,b,c);
}
Sum of 1,3 is 4
函数的返回值
返回语句
形式,return(表达式 )；
或 return 表达式 ;
或 return;
功能：使程序控制从被调用函数返回到调用函数中，
同时把返值带给调用函数
说明：
若无 return语句，遇 }时，自动返回调用函数
若函数类型与 return语句中表达式值的类型不一致，按前者为准，自动转换 ------函数调用转换
void型函数例 无返回值函数
void swap(int x,int y )
{ int temp;
temp=x;
x=y;
y=temp;
}
函数的返回值函数的返回值也就是函数值，是一个确定的值；
①如果一个函数 有返回值,
就 必须使用 return语句；
②一个函数中可以有一个以上的 return语句，但是无论执行到哪个 return语句，
都将结束函数的调用返回主调函数；
③ return语句中的 括号可以省略,return后面的 值可以是表达式 。
#include <stdio.h>
int max(int x,int y)
{
if(x>y)
return x;
else
return y;
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
函数值的类型
① 函数的类型即函数值的类型,如函数 max的类型是
int的,则函数值的类型也是
int的 ;
② 省略了类型说明的函数是 int型的；
③ return语句中表达式的类型一般应与函数类型一致；
④如果不一致，则需要进行类型转化，只有数值型数据可以进行自动类型转化，转化时以函数类型为准。
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
printstar()
{ printf("**********");
}
main()
{ int a;
a=printstar();
printf("%d",a);
}
例 函数带回不确定值输出,**********10
void printstar()
{ printf("**********");
}
main()
{ int a;
a=printstar();
printf("%d",a);
}
编译错误！
例 函数返回值类型转换
main()
{
int max(float,float);
float a,b;
int c;
scanf("%f,%f",&a,&b);
c=max(a,b);
printf("Max is %d\n",c);
}
max(float x,float y)
{ float z;
z=x>y?x:y;
return(z);
}
输入,23.4 2
输出,23
程序练习输入两个整数，计算他们的和并输出，
采用自定义函数。
调用形式函数名 (实参表 )
1、实参与形参 个数相等,类型一致,按顺序一一对应；
2、如果调用无参函数，则实参表可以省略，但 括号不能省 ；
3、实参表求值顺序，因系统而定，一般是 从 右向左,
为避免由此引起的混乱，
一般应在调用函数前计算出实参的值。
#include <stdio.h>
int f(int a,int b)
{ int c;
if(a>b) c=1;
else if(a==b) c=0;
else c=-1;
return c;}
void main()
{ int i=2,p;
p=f(i,++i);
printf(“%d”,p);}
7.4 函数的调用
调用方式
函数语句：
例 printstar();
printf(“I am a student!\n”);
说明：这种方式不要求函数带回返回值，仅完成一定的操作；
函数表达式：
例 m=max(a,b)*2;
说明：这种调用方式不能用于 void型函数；
函数参数：
例 printf(“%d”,max(a,b));
m=max(a,max(b,c));
常用库函数内置函数 头文件 用途
double sqrt(double x)
math.h
计算 x的平方根
double pow(double x,
double y)
计算 x的 y次幂
double ceil(double x) 求不小于 x的最小整数，并以
double形式显示
double floor(double x) 求不大于 x的最大整数，并以
double形式显示
int toupper(int x)
ctype.h
如果 x为小写字母，则返回对应的大写字母
int tolower(int x) 如果 x为大写字母，则返回对应的小写字母
int rand(void) stdlib.h 产生一个随机数
void exit(int retval) 终止程序求自然数 1-5的平方根和立方。
内置函数 sqrt 和 pow 示例
2 6 64
#include <stdio.h>
#include <math.h>
void main()
{
int x=1;
double squareroot,power;
for(x=1;x<=5;x++)
{
squareroot=sqrt(x);
power=pow(x,3);
printf(" %d的平方根,%3.2f\t%d的立方,%5.0f \n",
x,squareroot,x,power);
}
}
1的平方根,1.00 1的立方,1
2的平方根,1.41 2的立方,8
3的平方根,1.73 3的立方,27
4的平方根,2.00 4的立方,64
5的平方根,2.24 5的立方,125
Press any key to continue
函数调用的执行过程
1、按 从右至左 的顺序，计算出实参中各表达式的值；
2,按照位臵,将实参的值一一传递给形参；
3、执行被调用函数；
4、当遇到 return（表达式）
语句时，计算表达式的值，
并返回主调函数；
5、如果函数体中没有 return
语句，则 遇到 }自动返回 。
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
①
②
③
④
函数说明
在 C语言中，函数一般是,先定义，
后使用,,如果要先调用再定义，必须在调用之前进行 函数声明 。
所谓函数声明，指的是在函数尚未定义的时候，事先将该函数的有关信息通知编译系统，以便使编译正常进行。
函数说明在形式上与函数头部类似，
最后加一个分号 。原型说明中参数表里的参数名可以不写（ 只写参数类型 ）。
函数说明位臵,程序的数据说明部分
（函数内或外）
#include <stdio.h>
int max(int,int);
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
例 函数说明举例
float add(float x,float y)
{ float z;
z=x+y;
return(z);
}
main()
{ float a,b,c;
scanf("%f,%f",&a,&b);
c=add(a,b);
printf("sum is %f",c);
}
被调函数出现在主调函数之前，不必函数说明
main()
{ float add(float,float); /*function declaration*/
float a,b,c;
scanf("%f,%f",&a,&b);
c=add(a,b);
printf("sum is %f",c);
}
float add(float x,float y)
{ float z;
z=x+y;
return(z);
}
float add();
7.6 函数的嵌套与递归调用
嵌套调用
C规定,函数定义不可嵌套,但 可以嵌套调用 函数
main( )
调用函数 a
结束
a函数 b函数调用函数 b
函数调用结束后，总是回到 他的主调函数 中去,执行调用语句的下一个语句
void reverse()
{
::::::::::
::::::::::
}
#include<stdio.h>
void main()
{
:::::::::
palindrome();
::::::::
::::::::
}
void palindrome()
{
::::::::
reverse();
::::::::
}
函数嵌套调用从一个函数调用另一个函数称为函数的嵌套调用请思考该程序的运行结果
#include <stdio.h>
void printstar()
{printf(“**********\n”);}
void printmessage()
{printf(“Hello,world!\n”);
printstar();}
void main()
{
printstar();
printmessage();
}
**********
Hello,world!
**********
递归调用
定义,函数直接或间接的调用自身
f( )
调 f
说明
C编译系统对递归函数的自调用 次数没有限制
每调用函数一次，在内存堆栈区分配空间，用于存放函数变量、返回值等信息，所以递归次数过多，可能引起堆栈溢出
int f(int x)
{ int y,z;
……
z=f(y);
…….
return(2*z);
}
/* 此函数用于计算 a 的阶乘 */
int fac(int a)
{
if (a == 1)
return 1;
else
{
a = a * fac(a-1);
return a;
}
}
函数递归调用在一个函数体内调用自身称为函数的递归调用分析：
1、重复三次求阶乘的运算，只是每次的值不同而已；
2、将求阶乘的过程编成一个函数 fac(),以不同的参数 K值来调用函数；
§ 7.5 函数参数及其传递方式
形参与实参
形式参数,定义 函数时函数名后面括号中的 变量名
实际参数,调用 函数时函数名后面括号中的 表达式
c=max(a,b); （ main 函数）
（ max 函数）max(int x,int y)
{ int z;
z=x>y?x:y;
return(z);
}
例 比较两个数并输出大者 main()
{ int a,b,c;
scanf("%d%d",&a,&b);
c=max(a,b);
printf("Max is %d",c);
}
max(int x,int y)
{ int z;
z=x>y?x:y;
return(z);
}
形参实参
说明：
实参必须有确定的值,形参必须指定类型
形参与实参 类型一致，个数相同
形参在函数被调用前不占内存 ;函数调用时为形参分配内存；调用结束，内存释放
§ 7.5 函数参数及其传递方式
形参与实参
形式参数,定义 函数时函数名后面括号中的 变量名
实际参数,调用 函数时函数名后面括号中的 表达式例 计算 x的立方
#include <stdio.h>
float cube(float x)
{ return(x*x*x);}
main()
{ float a,product;
scanf("%f",&a);
product=cube(a);
printf(”Cube of %.4f is %.4f\n",a,product);
}
x
a
product
××
××
1.2
1.2
1.728
参数传递方式
值传递 方式
方式：函数调用时,为形参分配单元,并将实参的值 复制 到形参中；调用结束，形参单元被释放，实参单元仍保留并维持原值
特点：
形参与实参占用 不同 的内存单元
单向 传递
7 11x,y:调用前：
调用结束,7 11x,y:
例 交换两个数
swap(int a,int b)
{ int temp;
temp=a; a=b; b=temp;
}
#include <stdio.h>
main()
{ int x=7,y=11;
printf("%d,%d\n",x,y);
swap(x,y);
printf("%d,%d\n",x,y);
}
调用：
7 11a,b:
7 11x,y:
swap,7 11x,y:
11 7a,b:
temp
地址传递
方式：函数调用时，将数据的 存储地址 作为参数传递给形参
特点：
形参与实参占用 同样 的存储单元
“双向” 传递
实参和形参必须是 地址 常量或变量
数组名作函数参数
在主调函数与被调函数分别定义数组,且类型应一致
形参数组大小 (多维数组第一维 )可不指定
形参数组名是地址变量例 数组元素 与 数组名作函数参数比较
1
2
a
调用前
a[0]
a[1]
1
2
a
调用
a[0]
a[1]
1
2
x
y
2
1
x
y
交换
#include <stdio.h>
void swap2(int x,int y)
{ int z;
z=x; x=y; y=z;
}
main()
{ int a[2]={1,2};
swap2(a[0],a[1]);
printf(“%d,%d",a[0],a[1]);
}
值传递
1
2
a
返回
a[0]
a[1]
1
2
a
x
调用
2
1
a
x
交换
#include <stdio.h>
void swap2(int x[])
{ int z;
z=x[0]; x[0]=x[1]; x[1]=z;
}
main()
{ int a[2]={1,2};
swap2(a);
printf(“%d,%d",a[0],a[1]);
}
地址传递例 数组元素 与 数组名作函数参数比较
2
1
a
返回
a[0]
a[1]
1
2
a
调用前
a[0]
a[1]
形参与实参小结传递方式 实参 形参 传递方式值传递 常量、变量、表达式、数组元素变量 传值（ 单向 ）
地址传递 数组名 数组 传数组首地址
（ 双向 ）
例 求学生的平均成绩
#include <stdio.h>
float average(int stu[10],int n);
void main()
{ int score[10],i;
float av;
for( i=0; i<10; i++ )
scanf("%d",&score[i]);
av=average(score,10);
printf("Average is,%.2f",av);
}
float average(int stu[10],int n)
{ int i;
float av,total=0;
for( i=0; i<n; i++ )
total += stu[i];
av = total/n;
return av;
}
实参用数组名形参用数组定义,?int stu[ ]
.
.
2
1
0
9
score
56
23
12
….
….
88
stu
§ 变量的存储属性
概述
变量是对程序中数据的存储空间的抽象 内存
…….
main()
{ int a;
a=10;
printf(“%d”,a);
} 102000
2001
程序中使用变量名对内存操作
变量的属性
存储属性
存储器类型：寄存器、静态存储区、动态存储区
生存期,变量在某一时刻存在 ---静态变量与动态变量
作用域,变量在某区域内有效 ---局部变量与全局变量
变量的存储类型
auto -----自动型
register-----寄存器型
static ------静态型
extern -----全局型
变量定义格式,[存储类型 ] 数据类型 变量表 ;
§ 8.8 变量的存储属性
概述,变量是对程序中数据的存储空间的抽象如,int sum;
auto int a,b,c;
register int i;
static float x,y;
局部变量与全局变量
局部变量 ---内部变量
定义：在 函数内定义,只在本函数内有效
说明：
main中定义的变量只在 main中有效
不同函数中同名变量，占不同内存单元
形参属于局部变量
可定义在复合语句中有效的变量
float f1(int a)
{ int b,c;
…….
}
char f2(int x,int y)
{ int i,j;
……
}
main()
{ int m,n;
…….
}
a,b,c有效
x,y,i,j有效
m,n有效例 不同函数中同名变量
main()
{ int a,b;
a=3;
b=4;
printf("main:%d,%d\n",a,b);
sub();
printf("main:%d,%d\n",a,b);
}
sub()
{ int a,b;
a=6;
b=7;
printf("sub:%d,%d\n",a,b);
}
例 复合语句中变量
#define N 5
main()
{ int i;
int a[N]={1,2,3,4,5};
for i=0;i<N/2;i++)
{ int temp;
temp=a[i];
a[i]=a[N-i-1];
a[N-i-1]=temp;
}
for(i=0;i<N;i++)
printf("%d ",a[i]);
}
运行结果,5 4 3 2 1
例 复合语句中变量
#define N 5
main()
{ int i;
int a[N]={1,2,3,4,5};
for(i=0;i<N/2;i++)
{ int temp;
temp=a[i];
a[i]=a[N-i-1];
a[N-i-1]=temp;
}
for(i=0;i<N;i++)
printf("%d ",a[i]);
}
例 不同函数中同名变量
ain()
{ int a,b;
a=3;
b=4;
printf(" ain:,%d\n",a,b);
sub();
printf(" ain:,%d\n",a,b);
}
sub()
{ int a,b;
a=6;
b=7;
printf("sub,d,%d\n",a,b);
}
运行结果：
main:3,4
sub:6,7
main:3,4
全局变量 ---全局变量
定义：在 函数外定义,可为 本文件所有函数共用
有效范围：从 定义变量的位臵开始 到本源文件结束应尽量少使用全局变量，因为：
全局变量在程序全部执行过程中占用存储单元
降低了函数的通用性、可靠性，可移植性
降低程序清晰性，容易出错定义 说明
次数,只能 1次 可说明多次
位置,所有函数之外 函数内或函数外
分配内存,分配内存,可初始化 不分配内存,不可初始化
>
>
>
>
全局变量说明,extern 数据类型 变量表；
全局变量定义与全局变量说明不同
若全局变量与局部变量同名，则全局变量被屏蔽
int p=1,q=5;
float f1(int a)
{ int b,c;
…….
}
int f3()
{…..
}
char c1,c2;
char f2(int x,int y)
{ int i,j;
……
}
main()
{ int m,n;
…….
}
c1,c2的作用范围
p,q的作用范围
extern char c1,c2;
extern char c1,c2;
c1,c2
的作用范围扩展后 c1,c2
的作用范围扩展后例 全局变量定义与说明
int max(int x,int y)
{ int z;
z=x>y?x:y;
return(z);
}
main()
{ extern int a,b;
printf("max=%d",max(a,b));
}
int a=13,b=-8;
运行结果,max=13
extern int a,b;
int max()
{ int z;
z=a>b?a:b;
return(z);
}
main()
{ printf("max=%d",max());
}
int a=13,b=-8;
运行结果,max=13
int a=3,b=5;
max(int a,int b)
{ int c;
c=a>b?a:b;
return(c);
}
main()
{ int a=8;
printf("max=%d",max(a,b));
}
例 全局变量与局部变量运行结果,max=8
int i;
main()
{ void prt();
for(i=0;i<5;i++)
prt();
}
void prt()
{ for(i=0;i<5;i++)
printf(“*”);
printf(“\n”);
}
例 全局变量副作用运行结果,*****
内容回顾
§ 函数是程序中的一个相对 独立的单元或模块
§ 使用函数带来的好处,程序更清晰、易维护、
分模块方便设计与开发、提高代码的重用性
§ Ｃ语言提供了极为丰富的内置函数，要使用这些内置函数，需要 在程序前包含相应的头文件
§ 自定义函数是用户在程序中根据需要而编写的函数内容回顾
§ 函数的结构包括,返回值类型、函数名、参数列表、函数体
§ 函数原型说明以便向编译器指出该函数使用什么样的 格式和语法
§ 函数调用时程序控制流将转向被调函数，被调函数执行结束时，控制流返回主调函数
§ return 语句用于 向调用函数返回值
动态变量与静态变量
存储方式
静态存储：程序运行期间分配固定存储空间
动态存储：程序运行期间根据需要动态分配存储空间
内存用户区程序区静态存储区动态存储区全局变量、局部静态变量形参变量局部动态变量（ auto register)
函数调用现场保护和返回地址等
生存期
静态变量,从程序开始执行到程序结束
动态变量,从包含该变量定义的函数开始执行至函数执行结束
变量存储类型静态动态存储方式程序整个运行期间函数调用开始至结束生存期编译时赋初值,只赋一次每次函数调用时赋初值自动赋初值 0或空字符不确定未赋初值静态存储区动态区存储区 寄存器局部变量 全局变量作用域 定义变量的函数或复合语句内 本文件 其它文件
局部变量默认为 auto型
register型变量个数受限,且不能为 long,double,float型
局部 static变量具有 全局寿命 和 局部可见性
extern不是变量定义,可扩展全局 变量作用域
register 局部 staticauto 全局 static 全局存储类别例 文件 file1.c
int a;
main( )
{ …….
…….
f2;
…….
f1;
…….
}
f1( )
{ auto int b;
………
f2;
……..
}
f2( )
{ static int c;
………
}
C作用域
b作用域
a作用域
main f2 f1main f1f2 main
a生存期,
b生存期,
c生存期,
例 auto 变量的作用域
main()
{ int x=1;
void prt(void);
{ int x=3;
prt();
printf(“2nd x=%d\n”,x);
}
printf(“1st x=%d\n”,x);
}
void prt(void)
{ int x=5;
printf(“3th x=%d\n”,x);
}
运行结果：
3th x=5
2nd x=3
1st x=1
x=1作用域
x=1作用域
x=3作用域
x=5作用域
main()
{ void increment(void);
increment();
increment();
increment();
}
void increment(void)
{ int x=0;
x++;
printf(“%d\n”,x);
}
例 局部静态变量值具有可继承性运行结果,1
1
1
main()
{ void increment(void);
increment();
increment();
increment();
}
void increment(void)
{ static int x=0;
x++;
printf(“%d\n”,x);
}
运行结果,1
2
3
main()
{ void gx(),gy();
extern int x,y;
printf(“1,x=%d\ty=%d\n”,x,y);
y=246;
gx();
gy();
}
void gx()
{ extern int x,y;
x=135;
printf(“2,x=%d\ty=%d\n”,x,y);
}
int x,y;
void gy()
{ printf(“3,x=%d\ty=%d\n”,x,y);}
例 用 extern扩展全局变量作用域运行结果：
1,x=0 y=0
2,x=135 y=246
3,x=135 y=246
例 引用其它文件中的全局变量
int global;
extern float x;
main()
{ int local;
.
.
.
}
extern int global;
static int number;
func2()
{,
.
.
}
float x;
static int number;
func3()
{ extern int global;
.
.
.
}
file1.c
file2.c
file3.c
例 引用其它文件中的变量，输出 a?b和 a的 m次方
int a;
main()
{ int power(int n);
int b=3,c,d,m;
scanf("%d%d",&a,&m);
c=a*b;
printf("%d*%d=%d\n",a,b,c);
d=power(m);
printf("%d**%d=%d",a,m,d);
}
extern int a;
int power(int n)
{ int i,y=1;
for(i=1;i<=n;i++)
y*=a;
return(y);
}
练习题
1,C语言允许函数值类型缺省定义，此时该函数值隐含的类型是（ ）
A） float型 B） int型 C） long型 D） double型
2、在 C语句中，以下说明正确的是,（ ）
A）实参和与其对应的形参各占用独立的存储单元；
B）实参与其对应的形参共同占用一个存储单元；
C）只有当实参和与其对应的形参同名时才共占用存储单元；
D）形参是虚拟的，不占用存储单元。
3、下面关于 return语句使用的描述中错误的是 （ ）
A）被调用函数中可以不使用 return语句；
B）被调用函数中可以使用多个 return 语句；
C）被调用函数中如果有返回值就一定要用 return语句；
D）被调用函数中一个 return语句可返回多个值给主调函数。
B
A
D
1.建立函数的目的之一是 _________.
a)提高程序的执行效率 b)提高程序的可读性
c)减少程序的篇幅 d)减少程序文件所占内存
2．以下正确的函数定义形式是 ________.
a)double fun(int x,int y) b)double fun(int x; int y)
c)double fun(int x,int y);d)double fun(int x,y);
3.以下正确的说法是（ ）
A.用户若需调用标准库函数，调用前必须重新定义
B.系统根本不允许用户重新定义标准库函数
C.用户可以重新定义标准库函数，若如此，该函数失去原有含义
D.对所有标准库函数，调用前不必用预编译命令将该函数的头文件包含到用户源文件中练习题
B
A
B
4,C语言规定，简单变量做实参时，它和对应形参之间的数据传递方式为 ______.
A)地址传递 B）单向值传递 C）由用户指定传递方式
D）由实参传给形参，再由形参传回给实参
5.以下正确的函数形式是（ ）
A,double fun(int x,int y){z=x+y; return z;}
B,fun(int x,y){int z; return z;}
C,fun(x,y){int x,y; double z; z=x+y; retun z;}
D,double fun(int x,int y){double z;z=x+y; return z;}
6.以下程序的运行结果是 _____________
main(){ increment();
increment();
}
increment()
{ int x=0; x+=1; printf(“%d”,x);}
B
D
11
1.在Ｃ语言中，一个函数一般由两个部分组成，它们是 _________和 _________
2.以下不正确的说法为（ ）
A.在不同函数中可以使用相同名字的变量
B.形式参数是局部变量
C.在函数内定义的变量只在函数范围内有效
D.在函数内的复合语句中定义的变量在本函数内有效
3.函数调用不可以（ ）
A,出现在执行语句中 B.出现在一个表达式中
C,做为一个函数的实参 D.做为一个函数的形参练习题函数首部 函数体
D
D
4．以下程序的正确运行结果是 _________.
#include <stdio.h>
void num()
{extern int x,y,a=15,b=10; x=a-b; y=a+b; }
int x,y;
main()
{ int a=7,b=5; x=a+b; y=a-b;num();
printf("%d,%d",x,y);}
a)12,2 b)不确定 c)5,25 d)1,12
5.以下程序的运行结果是 _____________
int x;
main()
{ x=5; cude(); printf(“%d\n”,x);}
cude ( ) { x=x*x*x; }
C
125
6.以下程序的运行结果是 _____________
int a=5,b=7;
main()
{ int a=4,b=5,c;
c=plus(a,b);
printf(“A+B=%d\n”,c);
}
plus(int x,int y)
{ int z; z=x+y; return(z); }
7.下面 add函数的功能是求两个参数的和，并将和值返回调用函数。函数中错误的部分是 _____________，改正后应是 __________
void add(float a,float b)
{ float c; c=a+b; return c;}
A+B=9
函数类型 void
float
8.下面程序的运行结果是 _____________
main()
{ int i=5;
printf(“%d\n”,sub(i));}
sub(int n)
{ int a;
if(n==1) return 1;
a=n+sub(n-1);
return(a);}
9.以下程序的运行结果是 _____________
main()
{ int i=2,x=5,j=7;
fun(j,6);
printf(“i=%d;j=%d;x=%d\n”,i,j,x);}
fun(int i,int j)
{ int x=7;
printf(“i=%d;j=%d;x=%d\n”,i,j,x);}
15
i=7,j=6,x=7
i=2,j=7,x=5
练习二
P200 1,2,3
练习三
P200 4,5
Email,weimengjun@163.com
C语言程序设计 (第 2版 )
中南大学出版社成奋华 陈松乔 著内容提要
1、概述
2、函数的定义
3、函数的参数（变量、数组）和函数值
4、函数的调用
5、函数的嵌套调用
6、局部变量、全局变量及变量的存储类型
§ 7.1 概述
C是模块化程序设计语言源程序文件1
预编译命令说明部分 执行部分函数1 函数n
源程序文件i 源程序文件n
C程序
C程序结构?C是 函数式 语言
必须有且只能有一个名为 main的主函数
函数 不能嵌套定义,可以 嵌套 调用
模块化程序设计
基本思想：将一个大的程序按功能分割成一些小模块,
特点：
各模块相对独立、功能单一、结构清晰、接口简单
控制了程序设计的复杂性
提高元件的可靠性
缩短开发周期
避免程序开发的重复劳动
易于维护和功能扩充
开发方法,自上向下，逐步分解，分而治之程序说明
#include <stdio.h>
void star()
{printf(“**********\n”);}
void main()
{
star();
printf (“Hello,World! \n”);
}
1、程序从 main()函数中开始，调用其他的子函数以后，在 main()函数中结束；
2、所有的子函数都是 平行 的，任何子函数都不属于其他函数；
3、从用户的角度来看，函数可以分为：
标准函数，即库函数，如 printf()
自定义函数 如 star()
4、从函数形式来看，可分为：
无参数函数，如 star()
有参数函数，如 printf()。
§ 7.2 函数的定义
一般格式 合法标识符函数返回值类型缺省 int型无返回值 void
函数体函数类型 函数名 （ [形参类型说明表 ]）
{
说明部分语句部分
}
例 有参函数（现代风格）
int max(int x,int y)
{ int z;
z=x>y?x:y;
return(z);
}
例 有参函数（现代风格）
int max(int x,y)
{ int z;
z=x>y?x:y;
return(z);
}
例 空函数
dummy( )
{ }
函数体为空例 无参函数
printstar( )
{ printf(“**********\n”);
或
printstar(void )
{ printf(“**********\n”); }
局部变量：
函数体内定义的变量，其有效范围仅限于所在函数的内部，离开函数体则无意义比如：变量 x,y,z
函数参数和函数的值
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
一个 C程序由若干个函数组成，各函数调用时经常需要传递一些数据，即 调用函数 把参数传递给 被调用函数,经 被调用函数处理后，得到一个确切的结果，
在返回调用函数时，把这个结果带回 调用函数 。
调用函数 被调用函数
…………
c=max(a,b);
…………
int max(int x,int y)
…………
return(z);
a,b
z
函数参数：用于函数间数据的传递；
形式参数,定义 函数时使用的参数；
实际参数,引用 函数时使用的参数；
函数 max有两个形式参数 x,y
参数 x和 y只能在 max中使用
a和 b是主函数中定义的变量
main函数调用函数 max
a和 b为函数 max的实参形式参数和实际参数
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
说明：
1、定义函数时，必须说明形参的类型，形参必须是 变量 或者 数组 ；
2、实参可以是 常量,变量 或者 表达式 ；
3,形参与实参的类型必须一致,字符型和整型可以互相匹配；
4,C语言中，形参对实参的传递是,值传递,，即单向传递。它仅由参数的相对位臵决定，与名字无关。
形式参数和实际参数
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
看程序，写出运行结果
#include <stdio.h>
int sum(int a,int b)
{ a=a+b; b=a+b; return a; }
void main()
{
int a=1,b=3,c;
c=sum(a,b);
printf(“sum of %d,%d is %d\n”,a,b,c);
}
Sum of 1,3 is 4
函数的返回值
返回语句
形式,return(表达式 )；
或 return 表达式 ;
或 return;
功能：使程序控制从被调用函数返回到调用函数中，
同时把返值带给调用函数
说明：
若无 return语句，遇 }时，自动返回调用函数
若函数类型与 return语句中表达式值的类型不一致，按前者为准，自动转换 ------函数调用转换
void型函数例 无返回值函数
void swap(int x,int y )
{ int temp;
temp=x;
x=y;
y=temp;
}
函数的返回值函数的返回值也就是函数值，是一个确定的值；
①如果一个函数 有返回值,
就 必须使用 return语句；
②一个函数中可以有一个以上的 return语句，但是无论执行到哪个 return语句，
都将结束函数的调用返回主调函数；
③ return语句中的 括号可以省略,return后面的 值可以是表达式 。
#include <stdio.h>
int max(int x,int y)
{
if(x>y)
return x;
else
return y;
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
函数值的类型
① 函数的类型即函数值的类型,如函数 max的类型是
int的,则函数值的类型也是
int的 ;
② 省略了类型说明的函数是 int型的；
③ return语句中表达式的类型一般应与函数类型一致；
④如果不一致，则需要进行类型转化，只有数值型数据可以进行自动类型转化，转化时以函数类型为准。
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
printstar()
{ printf("**********");
}
main()
{ int a;
a=printstar();
printf("%d",a);
}
例 函数带回不确定值输出,**********10
void printstar()
{ printf("**********");
}
main()
{ int a;
a=printstar();
printf("%d",a);
}
编译错误！
例 函数返回值类型转换
main()
{
int max(float,float);
float a,b;
int c;
scanf("%f,%f",&a,&b);
c=max(a,b);
printf("Max is %d\n",c);
}
max(float x,float y)
{ float z;
z=x>y?x:y;
return(z);
}
输入,23.4 2
输出,23
程序练习输入两个整数，计算他们的和并输出，
采用自定义函数。
调用形式函数名 (实参表 )
1、实参与形参 个数相等,类型一致,按顺序一一对应；
2、如果调用无参函数，则实参表可以省略，但 括号不能省 ；
3、实参表求值顺序，因系统而定，一般是 从 右向左,
为避免由此引起的混乱，
一般应在调用函数前计算出实参的值。
#include <stdio.h>
int f(int a,int b)
{ int c;
if(a>b) c=1;
else if(a==b) c=0;
else c=-1;
return c;}
void main()
{ int i=2,p;
p=f(i,++i);
printf(“%d”,p);}
7.4 函数的调用
调用方式
函数语句：
例 printstar();
printf(“I am a student!\n”);
说明：这种方式不要求函数带回返回值，仅完成一定的操作；
函数表达式：
例 m=max(a,b)*2;
说明：这种调用方式不能用于 void型函数；
函数参数：
例 printf(“%d”,max(a,b));
m=max(a,max(b,c));
常用库函数内置函数 头文件 用途
double sqrt(double x)
math.h
计算 x的平方根
double pow(double x,
double y)
计算 x的 y次幂
double ceil(double x) 求不小于 x的最小整数，并以
double形式显示
double floor(double x) 求不大于 x的最大整数，并以
double形式显示
int toupper(int x)
ctype.h
如果 x为小写字母，则返回对应的大写字母
int tolower(int x) 如果 x为大写字母，则返回对应的小写字母
int rand(void) stdlib.h 产生一个随机数
void exit(int retval) 终止程序求自然数 1-5的平方根和立方。
内置函数 sqrt 和 pow 示例
2 6 64
#include <stdio.h>
#include <math.h>
void main()
{
int x=1;
double squareroot,power;
for(x=1;x<=5;x++)
{
squareroot=sqrt(x);
power=pow(x,3);
printf(" %d的平方根,%3.2f\t%d的立方,%5.0f \n",
x,squareroot,x,power);
}
}
1的平方根,1.00 1的立方,1
2的平方根,1.41 2的立方,8
3的平方根,1.73 3的立方,27
4的平方根,2.00 4的立方,64
5的平方根,2.24 5的立方,125
Press any key to continue
函数调用的执行过程
1、按 从右至左 的顺序，计算出实参中各表达式的值；
2,按照位臵,将实参的值一一传递给形参；
3、执行被调用函数；
4、当遇到 return（表达式）
语句时，计算表达式的值，
并返回主调函数；
5、如果函数体中没有 return
语句，则 遇到 }自动返回 。
#include <stdio.h>
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
①
②
③
④
函数说明
在 C语言中，函数一般是,先定义，
后使用,,如果要先调用再定义，必须在调用之前进行 函数声明 。
所谓函数声明，指的是在函数尚未定义的时候，事先将该函数的有关信息通知编译系统，以便使编译正常进行。
函数说明在形式上与函数头部类似，
最后加一个分号 。原型说明中参数表里的参数名可以不写（ 只写参数类型 ）。
函数说明位臵,程序的数据说明部分
（函数内或外）
#include <stdio.h>
int max(int,int);
void main()
{
int a,b,c;
scanf(“%d,%d”,&a,&b);
c=max(a,b);
printf(“Max is %d\n”,c);
}
int max(int x,int y)
{
int z;
z=(x>y)?x:y;
return(z);
}
例 函数说明举例
float add(float x,float y)
{ float z;
z=x+y;
return(z);
}
main()
{ float a,b,c;
scanf("%f,%f",&a,&b);
c=add(a,b);
printf("sum is %f",c);
}
被调函数出现在主调函数之前，不必函数说明
main()
{ float add(float,float); /*function declaration*/
float a,b,c;
scanf("%f,%f",&a,&b);
c=add(a,b);
printf("sum is %f",c);
}
float add(float x,float y)
{ float z;
z=x+y;
return(z);
}
float add();
7.6 函数的嵌套与递归调用
嵌套调用
C规定,函数定义不可嵌套,但 可以嵌套调用 函数
main( )
调用函数 a
结束
a函数 b函数调用函数 b
函数调用结束后，总是回到 他的主调函数 中去,执行调用语句的下一个语句
void reverse()
{
::::::::::
::::::::::
}
#include<stdio.h>
void main()
{
:::::::::
palindrome();
::::::::
::::::::
}
void palindrome()
{
::::::::
reverse();
::::::::
}
函数嵌套调用从一个函数调用另一个函数称为函数的嵌套调用请思考该程序的运行结果
#include <stdio.h>
void printstar()
{printf(“**********\n”);}
void printmessage()
{printf(“Hello,world!\n”);
printstar();}
void main()
{
printstar();
printmessage();
}
**********
Hello,world!
**********
递归调用
定义,函数直接或间接的调用自身
f( )
调 f
说明
C编译系统对递归函数的自调用 次数没有限制
每调用函数一次，在内存堆栈区分配空间，用于存放函数变量、返回值等信息，所以递归次数过多，可能引起堆栈溢出
int f(int x)
{ int y,z;
……
z=f(y);
…….
return(2*z);
}
/* 此函数用于计算 a 的阶乘 */
int fac(int a)
{
if (a == 1)
return 1;
else
{
a = a * fac(a-1);
return a;
}
}
函数递归调用在一个函数体内调用自身称为函数的递归调用分析：
1、重复三次求阶乘的运算，只是每次的值不同而已；
2、将求阶乘的过程编成一个函数 fac(),以不同的参数 K值来调用函数；
§ 7.5 函数参数及其传递方式
形参与实参
形式参数,定义 函数时函数名后面括号中的 变量名
实际参数,调用 函数时函数名后面括号中的 表达式
c=max(a,b); （ main 函数）
（ max 函数）max(int x,int y)
{ int z;
z=x>y?x:y;
return(z);
}
例 比较两个数并输出大者 main()
{ int a,b,c;
scanf("%d%d",&a,&b);
c=max(a,b);
printf("Max is %d",c);
}
max(int x,int y)
{ int z;
z=x>y?x:y;
return(z);
}
形参实参
说明：
实参必须有确定的值,形参必须指定类型
形参与实参 类型一致，个数相同
形参在函数被调用前不占内存 ;函数调用时为形参分配内存；调用结束，内存释放
§ 7.5 函数参数及其传递方式
形参与实参
形式参数,定义 函数时函数名后面括号中的 变量名
实际参数,调用 函数时函数名后面括号中的 表达式例 计算 x的立方
#include <stdio.h>
float cube(float x)
{ return(x*x*x);}
main()
{ float a,product;
scanf("%f",&a);
product=cube(a);
printf(”Cube of %.4f is %.4f\n",a,product);
}
x
a
product
××
××
1.2
1.2
1.728
参数传递方式
值传递 方式
方式：函数调用时,为形参分配单元,并将实参的值 复制 到形参中；调用结束，形参单元被释放，实参单元仍保留并维持原值
特点：
形参与实参占用 不同 的内存单元
单向 传递
7 11x,y:调用前：
调用结束,7 11x,y:
例 交换两个数
swap(int a,int b)
{ int temp;
temp=a; a=b; b=temp;
}
#include <stdio.h>
main()
{ int x=7,y=11;
printf("%d,%d\n",x,y);
swap(x,y);
printf("%d,%d\n",x,y);
}
调用：
7 11a,b:
7 11x,y:
swap,7 11x,y:
11 7a,b:
temp
地址传递
方式：函数调用时，将数据的 存储地址 作为参数传递给形参
特点：
形参与实参占用 同样 的存储单元
“双向” 传递
实参和形参必须是 地址 常量或变量
数组名作函数参数
在主调函数与被调函数分别定义数组,且类型应一致
形参数组大小 (多维数组第一维 )可不指定
形参数组名是地址变量例 数组元素 与 数组名作函数参数比较
1
2
a
调用前
a[0]
a[1]
1
2
a
调用
a[0]
a[1]
1
2
x
y
2
1
x
y
交换
#include <stdio.h>
void swap2(int x,int y)
{ int z;
z=x; x=y; y=z;
}
main()
{ int a[2]={1,2};
swap2(a[0],a[1]);
printf(“%d,%d",a[0],a[1]);
}
值传递
1
2
a
返回
a[0]
a[1]
1
2
a
x
调用
2
1
a
x
交换
#include <stdio.h>
void swap2(int x[])
{ int z;
z=x[0]; x[0]=x[1]; x[1]=z;
}
main()
{ int a[2]={1,2};
swap2(a);
printf(“%d,%d",a[0],a[1]);
}
地址传递例 数组元素 与 数组名作函数参数比较
2
1
a
返回
a[0]
a[1]
1
2
a
调用前
a[0]
a[1]
形参与实参小结传递方式 实参 形参 传递方式值传递 常量、变量、表达式、数组元素变量 传值（ 单向 ）
地址传递 数组名 数组 传数组首地址
（ 双向 ）
例 求学生的平均成绩
#include <stdio.h>
float average(int stu[10],int n);
void main()
{ int score[10],i;
float av;
for( i=0; i<10; i++ )
scanf("%d",&score[i]);
av=average(score,10);
printf("Average is,%.2f",av);
}
float average(int stu[10],int n)
{ int i;
float av,total=0;
for( i=0; i<n; i++ )
total += stu[i];
av = total/n;
return av;
}
实参用数组名形参用数组定义,?int stu[ ]
.
.
2
1
0
9
score
56
23
12
….
….
88
stu
§ 变量的存储属性
概述
变量是对程序中数据的存储空间的抽象 内存
…….
main()
{ int a;
a=10;
printf(“%d”,a);
} 102000
2001
程序中使用变量名对内存操作
变量的属性
存储属性
存储器类型：寄存器、静态存储区、动态存储区
生存期,变量在某一时刻存在 ---静态变量与动态变量
作用域,变量在某区域内有效 ---局部变量与全局变量
变量的存储类型
auto -----自动型
register-----寄存器型
static ------静态型
extern -----全局型
变量定义格式,[存储类型 ] 数据类型 变量表 ;
§ 8.8 变量的存储属性
概述,变量是对程序中数据的存储空间的抽象如,int sum;
auto int a,b,c;
register int i;
static float x,y;
局部变量与全局变量
局部变量 ---内部变量
定义：在 函数内定义,只在本函数内有效
说明：
main中定义的变量只在 main中有效
不同函数中同名变量，占不同内存单元
形参属于局部变量
可定义在复合语句中有效的变量
float f1(int a)
{ int b,c;
…….
}
char f2(int x,int y)
{ int i,j;
……
}
main()
{ int m,n;
…….
}
a,b,c有效
x,y,i,j有效
m,n有效例 不同函数中同名变量
main()
{ int a,b;
a=3;
b=4;
printf("main:%d,%d\n",a,b);
sub();
printf("main:%d,%d\n",a,b);
}
sub()
{ int a,b;
a=6;
b=7;
printf("sub:%d,%d\n",a,b);
}
例 复合语句中变量
#define N 5
main()
{ int i;
int a[N]={1,2,3,4,5};
for i=0;i<N/2;i++)
{ int temp;
temp=a[i];
a[i]=a[N-i-1];
a[N-i-1]=temp;
}
for(i=0;i<N;i++)
printf("%d ",a[i]);
}
运行结果,5 4 3 2 1
例 复合语句中变量
#define N 5
main()
{ int i;
int a[N]={1,2,3,4,5};
for(i=0;i<N/2;i++)
{ int temp;
temp=a[i];
a[i]=a[N-i-1];
a[N-i-1]=temp;
}
for(i=0;i<N;i++)
printf("%d ",a[i]);
}
例 不同函数中同名变量
ain()
{ int a,b;
a=3;
b=4;
printf(" ain:,%d\n",a,b);
sub();
printf(" ain:,%d\n",a,b);
}
sub()
{ int a,b;
a=6;
b=7;
printf("sub,d,%d\n",a,b);
}
运行结果：
main:3,4
sub:6,7
main:3,4
全局变量 ---全局变量
定义：在 函数外定义,可为 本文件所有函数共用
有效范围：从 定义变量的位臵开始 到本源文件结束应尽量少使用全局变量，因为：
全局变量在程序全部执行过程中占用存储单元
降低了函数的通用性、可靠性，可移植性
降低程序清晰性，容易出错定义 说明
次数,只能 1次 可说明多次
位置,所有函数之外 函数内或函数外
分配内存,分配内存,可初始化 不分配内存,不可初始化
>
>
>
>
全局变量说明,extern 数据类型 变量表；
全局变量定义与全局变量说明不同
若全局变量与局部变量同名，则全局变量被屏蔽
int p=1,q=5;
float f1(int a)
{ int b,c;
…….
}
int f3()
{…..
}
char c1,c2;
char f2(int x,int y)
{ int i,j;
……
}
main()
{ int m,n;
…….
}
c1,c2的作用范围
p,q的作用范围
extern char c1,c2;
extern char c1,c2;
c1,c2
的作用范围扩展后 c1,c2
的作用范围扩展后例 全局变量定义与说明
int max(int x,int y)
{ int z;
z=x>y?x:y;
return(z);
}
main()
{ extern int a,b;
printf("max=%d",max(a,b));
}
int a=13,b=-8;
运行结果,max=13
extern int a,b;
int max()
{ int z;
z=a>b?a:b;
return(z);
}
main()
{ printf("max=%d",max());
}
int a=13,b=-8;
运行结果,max=13
int a=3,b=5;
max(int a,int b)
{ int c;
c=a>b?a:b;
return(c);
}
main()
{ int a=8;
printf("max=%d",max(a,b));
}
例 全局变量与局部变量运行结果,max=8
int i;
main()
{ void prt();
for(i=0;i<5;i++)
prt();
}
void prt()
{ for(i=0;i<5;i++)
printf(“*”);
printf(“\n”);
}
例 全局变量副作用运行结果,*****
内容回顾
§ 函数是程序中的一个相对 独立的单元或模块
§ 使用函数带来的好处,程序更清晰、易维护、
分模块方便设计与开发、提高代码的重用性
§ Ｃ语言提供了极为丰富的内置函数，要使用这些内置函数，需要 在程序前包含相应的头文件
§ 自定义函数是用户在程序中根据需要而编写的函数内容回顾
§ 函数的结构包括,返回值类型、函数名、参数列表、函数体
§ 函数原型说明以便向编译器指出该函数使用什么样的 格式和语法
§ 函数调用时程序控制流将转向被调函数，被调函数执行结束时，控制流返回主调函数
§ return 语句用于 向调用函数返回值
动态变量与静态变量
存储方式
静态存储：程序运行期间分配固定存储空间
动态存储：程序运行期间根据需要动态分配存储空间
内存用户区程序区静态存储区动态存储区全局变量、局部静态变量形参变量局部动态变量（ auto register)
函数调用现场保护和返回地址等
生存期
静态变量,从程序开始执行到程序结束
动态变量,从包含该变量定义的函数开始执行至函数执行结束
变量存储类型静态动态存储方式程序整个运行期间函数调用开始至结束生存期编译时赋初值,只赋一次每次函数调用时赋初值自动赋初值 0或空字符不确定未赋初值静态存储区动态区存储区 寄存器局部变量 全局变量作用域 定义变量的函数或复合语句内 本文件 其它文件
局部变量默认为 auto型
register型变量个数受限,且不能为 long,double,float型
局部 static变量具有 全局寿命 和 局部可见性
extern不是变量定义,可扩展全局 变量作用域
register 局部 staticauto 全局 static 全局存储类别例 文件 file1.c
int a;
main( )
{ …….
…….
f2;
…….
f1;
…….
}
f1( )
{ auto int b;
………
f2;
……..
}
f2( )
{ static int c;
………
}
C作用域
b作用域
a作用域
main f2 f1main f1f2 main
a生存期,
b生存期,
c生存期,
例 auto 变量的作用域
main()
{ int x=1;
void prt(void);
{ int x=3;
prt();
printf(“2nd x=%d\n”,x);
}
printf(“1st x=%d\n”,x);
}
void prt(void)
{ int x=5;
printf(“3th x=%d\n”,x);
}
运行结果：
3th x=5
2nd x=3
1st x=1
x=1作用域
x=1作用域
x=3作用域
x=5作用域
main()
{ void increment(void);
increment();
increment();
increment();
}
void increment(void)
{ int x=0;
x++;
printf(“%d\n”,x);
}
例 局部静态变量值具有可继承性运行结果,1
1
1
main()
{ void increment(void);
increment();
increment();
increment();
}
void increment(void)
{ static int x=0;
x++;
printf(“%d\n”,x);
}
运行结果,1
2
3
main()
{ void gx(),gy();
extern int x,y;
printf(“1,x=%d\ty=%d\n”,x,y);
y=246;
gx();
gy();
}
void gx()
{ extern int x,y;
x=135;
printf(“2,x=%d\ty=%d\n”,x,y);
}
int x,y;
void gy()
{ printf(“3,x=%d\ty=%d\n”,x,y);}
例 用 extern扩展全局变量作用域运行结果：
1,x=0 y=0
2,x=135 y=246
3,x=135 y=246
例 引用其它文件中的全局变量
int global;
extern float x;
main()
{ int local;
.
.
.
}
extern int global;
static int number;
func2()
{,
.
.
}
float x;
static int number;
func3()
{ extern int global;
.
.
.
}
file1.c
file2.c
file3.c
例 引用其它文件中的变量，输出 a?b和 a的 m次方
int a;
main()
{ int power(int n);
int b=3,c,d,m;
scanf("%d%d",&a,&m);
c=a*b;
printf("%d*%d=%d\n",a,b,c);
d=power(m);
printf("%d**%d=%d",a,m,d);
}
extern int a;
int power(int n)
{ int i,y=1;
for(i=1;i<=n;i++)
y*=a;
return(y);
}
练习题
1,C语言允许函数值类型缺省定义，此时该函数值隐含的类型是（ ）
A） float型 B） int型 C） long型 D） double型
2、在 C语句中，以下说明正确的是,（ ）
A）实参和与其对应的形参各占用独立的存储单元；
B）实参与其对应的形参共同占用一个存储单元；
C）只有当实参和与其对应的形参同名时才共占用存储单元；
D）形参是虚拟的，不占用存储单元。
3、下面关于 return语句使用的描述中错误的是 （ ）
A）被调用函数中可以不使用 return语句；
B）被调用函数中可以使用多个 return 语句；
C）被调用函数中如果有返回值就一定要用 return语句；
D）被调用函数中一个 return语句可返回多个值给主调函数。
B
A
D
1.建立函数的目的之一是 _________.
a)提高程序的执行效率 b)提高程序的可读性
c)减少程序的篇幅 d)减少程序文件所占内存
2．以下正确的函数定义形式是 ________.
a)double fun(int x,int y) b)double fun(int x; int y)
c)double fun(int x,int y);d)double fun(int x,y);
3.以下正确的说法是（ ）
A.用户若需调用标准库函数，调用前必须重新定义
B.系统根本不允许用户重新定义标准库函数
C.用户可以重新定义标准库函数，若如此，该函数失去原有含义
D.对所有标准库函数，调用前不必用预编译命令将该函数的头文件包含到用户源文件中练习题
B
A
B
4,C语言规定，简单变量做实参时，它和对应形参之间的数据传递方式为 ______.
A)地址传递 B）单向值传递 C）由用户指定传递方式
D）由实参传给形参，再由形参传回给实参
5.以下正确的函数形式是（ ）
A,double fun(int x,int y){z=x+y; return z;}
B,fun(int x,y){int z; return z;}
C,fun(x,y){int x,y; double z; z=x+y; retun z;}
D,double fun(int x,int y){double z;z=x+y; return z;}
6.以下程序的运行结果是 _____________
main(){ increment();
increment();
}
increment()
{ int x=0; x+=1; printf(“%d”,x);}
B
D
11
1.在Ｃ语言中，一个函数一般由两个部分组成，它们是 _________和 _________
2.以下不正确的说法为（ ）
A.在不同函数中可以使用相同名字的变量
B.形式参数是局部变量
C.在函数内定义的变量只在函数范围内有效
D.在函数内的复合语句中定义的变量在本函数内有效
3.函数调用不可以（ ）
A,出现在执行语句中 B.出现在一个表达式中
C,做为一个函数的实参 D.做为一个函数的形参练习题函数首部 函数体
D
D
4．以下程序的正确运行结果是 _________.
#include <stdio.h>
void num()
{extern int x,y,a=15,b=10; x=a-b; y=a+b; }
int x,y;
main()
{ int a=7,b=5; x=a+b; y=a-b;num();
printf("%d,%d",x,y);}
a)12,2 b)不确定 c)5,25 d)1,12
5.以下程序的运行结果是 _____________
int x;
main()
{ x=5; cude(); printf(“%d\n”,x);}
cude ( ) { x=x*x*x; }
C
125
6.以下程序的运行结果是 _____________
int a=5,b=7;
main()
{ int a=4,b=5,c;
c=plus(a,b);
printf(“A+B=%d\n”,c);
}
plus(int x,int y)
{ int z; z=x+y; return(z); }
7.下面 add函数的功能是求两个参数的和，并将和值返回调用函数。函数中错误的部分是 _____________，改正后应是 __________
void add(float a,float b)
{ float c; c=a+b; return c;}
A+B=9
函数类型 void
float
8.下面程序的运行结果是 _____________
main()
{ int i=5;
printf(“%d\n”,sub(i));}
sub(int n)
{ int a;
if(n==1) return 1;
a=n+sub(n-1);
return(a);}
9.以下程序的运行结果是 _____________
main()
{ int i=2,x=5,j=7;
fun(j,6);
printf(“i=%d;j=%d;x=%d\n”,i,j,x);}
fun(int i,int j)
{ int x=7;
printf(“i=%d;j=%d;x=%d\n”,i,j,x);}
15
i=7,j=6,x=7
i=2,j=7,x=5
练习二
P200 1,2,3
练习三
P200 4,5
