第八章 函数
§ 8.1 概述
模块化程序设计
基本思想：将一个大的程序按功能分割成一些小模块,
特点：
各模块相对独立、功能单一、结构清晰、接口简单
控制了程序设计的复杂性
提高元件的可靠性
缩短开发周期
避免程序开发的重复劳动
易于维护和功能扩充
开发方法,自上向下,逐步分解，分而治之
C是模块化程序设计语言源程序文件1
预编译命令说明部分 执行部分函数1 函数n
源程序文件i 源程序文件n
C程序
C程序结构
C是 函数式 语言
必须有且只能有一个名为 main的主函数
C程序的执行总是 从 main函数开始，在 main中结束
函数 不能嵌套定义,可以 嵌套 调用
函数分类
从用户角度
标准函数（库函数）：由系统提供
用户自定义函数
从函数形式
无参函数
有参函数使用 库函数 应注意：
1、函数功能
2、函数参数的数目和顺序，及各参数意义和类型
3、函数返回值意义和类型
4、需要使用的包含文件
§ 8.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”); }
函数类型 函数名（形参表）
形参类型说明
{
说明部分语句部分
}
传统风格,
例 有参函数（传统风格）
int max(x,y)
int x,y;
{ int z;
z=x>y?x:y;
return(z);
}
§ 8.3 函数的返回值
返回语句
形式,return(表达式 )；
或 return 表达式 ;
或 return;
功能：使程序控制从被调用函数返回到调用函数中，
同时把返值带给调用函数
说明：
函数中可有多个 return语句
若无 return语句，遇 }时，自动返回调用函数
若函数类型与 return语句中表达式值的类型不一致，按前者为准，自动转换 ------函数调用转换
void型函数例 无返回值函数
void swap(int x,int y )
{ int temp;
temp=x;
x=y;
y=temp;
}
printstar()
{ printf("**********");
}
main()
{ int a;
a=printstar();
printf("%d",a);
}
例 函数带回不确定值输出,10
void printstar()
{ printf("**********");
}
main()
{ int a;
a=printstar();
printf("%d",a);
}
编译错误！
例 函数返回值类型转换
main()
{ 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);
}
§ 8.4 函数的调用
调用形式函数名 (实参表 );
说明：
实参与形参 个数相等,类型一致,按顺序一一对应
实参表求值顺序，因系统而定（ Turbo C 自右向左 ）
main()
{ int i=2,p;
p=f(i,++i);
printf("%d",p);
}
int f(int a,int b)
{ int c;
if(a>b) c=1;
else if(a==b) c=0;
else c=-1;
return(c);
}
例 参数求值顺序
main()
{ int i=2,p;
p=f(i,i++);
printf("%d",p);
}
int f(int a,int b)
{ int c;
if(a>b) c=1;
else if(a==b) c=0;
else c=-1;
return(c);
}
运行结果,0 运行结果,1
调用方式
函数语句：
例 printstar();
printf(“Hello,World!\n”);
函数表达式：
例 m=max(a,b)*2;
函数参数：
例 printf(“%d”,max(a,b));
m=max(a,max(b,c));
函数说明
对被调用函数要求：
必须是 已存在 的函数
库函数,#include <*.h>
用户自定义函数,函数类型说明
函数说明
一般形式,函数类型 函数名 (形参类型 [形参名 ],….,);
或 函数类型 函数名 ();
作用：告诉编译系统 函数类型、参数个数及类型，以便检验
函数定义 与 函数说明 不同
函数说明位置,程序的数据说明部分（函数内或外）
下列情况下，可不作函数说明
若函数返值是 char或 int型,系统自动按 int型处理
被调用函数定义出现在主调函数之前
有些系统 (如 Borland C++)要求函数说明指出函数返值类型和形参类型，并且对 void 和 int 型函数也要进行函数说明例 函数说明举例
main()
{ 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);
}
int型函数可不作函数说明
（ Borland C++不行）
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);
}
被调函数出现在主调函数之前，不必函数说明
/*ch8_5.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();
§ 8.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);
}
形参实参
说明：
实参必须有确定的值
形参必须指定类型
形参与实参 类型一致，个数相同
若形参与实参类型不一致，自动按形参类型转换 ———函数调用转换
形参在函数被调用前不占内存 ;函数调用时为形参分配内存；
调用结束，内存释放
§ 8.5 函数参数及其传递方式
形参与实参
形式参数：定义函数时函数名后面括号中的变量名
实际参数：调用函数时函数名后面括号中的表达式例 计算 x的立方
#include <stdio.h>
float cube(float x)
{ return(x*x*x);
}
main()
{ float a,product;
printf("Please input value of a:");
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:
例 交换两个数
/*ch7_2.c*/
#include <stdio.h>
main()
{ int x=7,y=11;
printf("x=%d,\ty=%d\n",x,y);
printf("swapped:\n");
swap(x,y);
printf("x=%d,\ty=%d\n",x,y);
}
swap(int a,int b)
{ int temp;
temp=a; a=b; b=temp;
}
调用：
7 11a,b:
7 11x,y:
swap,7 11x,y:
11 7a,b:
temp
§ 8.6 函数的嵌套与递归调用
嵌套调用
C规定,函数定义不可嵌套,但 可以嵌套调用 函数
main( )
调用函数 a
结束
a函数 b函数调用函数 b
例 求三个数中最大数和最小数的差值
#include <stdio.h>
int dif(int x,int y,int z);
int max(int x,int y,int z);
int min(int x,int y,int z);
void main()
{ int a,b,c,d;
scanf("%d%d%d",&a,&b,&c);
d=dif(a,b,c);
printf("Max-Min=%d\n",d);
}
Ch7_202.c
int dif(int x,int y,int z)
{ return max(x,y,z)-min(x,y,z); }
int max(int x,int y,int z)
{ int r;
r=x>y?x:y;
return(r>z?r:z);
}
int min(int x,int y,int z)
{ int r;
r=x<y?x:y;
return(r<z?r:z);
}main( )
调用函数 dif
输出结束
dif函数 max函数调用函数 max
调用函数 min min函数例 用弦截法求方程根 080165 23 xxx
x
y
f(x)
0
x1
x2
x
f(x1)
f(x2)
)()(
)()(
12
1221
xfxf
xfxxfxx
求 f(x1)与 f(x2)连线与 x轴的交点 x
输入 x1,x2,求 f(x1),f(x2)
直到 f(x1)与 f(x2)异号
y=f(x),y1=f(x1)
y与 y1同号真 假
x1=x
y1=y
x2=x
直到 |y|<?
root=x 输出 root
root函数运行情况：
Input x1,x2:
2,6?
A root of equation is 5.0000
main( )
调用函数 root
输出根 x
结束
root函数 xpoint函数调用函数 xpoint 调用函数 f
f函数
递归调用
定义：函数直接或间接的调用自身叫函数的递归调用
f( )
调 f 调 f2 调 f1
f1( ) f2( )
说明
C编译系统对递归函数的自调用次数没有限制
每调用函数一次，在内存堆栈区分配空间，用于存放函数变量、返回值等信息，所以递归次数过多，可能引起堆栈溢出
int f(int x)
{ int y,z;
……
z=f(y);
…….
return(2*z);
}
int f1(int x)
{ int y,z;
……
z=f2(y);
…….
return(2*z);
}
int f2(int t)
{ int a,c;
……
c=f1(a);
…….
return(3+c);
}
例 求 n的阶乘
)1()!1(
)1,0(1!
nnn
nn
/*ch8_8.c*/
#include <stdio.h>
int fac(int n)
{ int f;
if(n<0) printf("n<0,data error!");
else if(n==0||n==1) f=1;
else f=fac(n-1)*n;
return(f);
}
main()
{ int n,y;
printf("Input a integer number:");
scanf("%d",&n);
y=fac(n);
printf("%d! =%15d",n,y);
}
例 Hanoi问题 void move(char getone,char putone){ printf("%c--->%c\n",getone,putone); }
void hanoi(int n,char one,char two,char three)
{ if(n==1) move(one,three);
else
{ hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
}
}
main()
{ int m;
printf("Input the number of disks:");
scanf("%d",&m);
printf("The steps to moving %3d disks:\n",m);
hanoi(m,'A','B','C');
}
D:\fengyi\bkc\power\power.c
A B C
§ 8.7 数组作为函数参数
数组元素作函数实参 ——值传递例 两个数组大小比较
4
3
2
1
0
5
a
56
23
12
10
76
88
4
3
2
1
0
5
b
21
23
43
98
66
54
n=0
m=0
k=0
i
n=0
m=0
k=1
i
n=0
m=1
k=1
i
n=1
m=1
k=1
i
n=1
m=1
k=2
i
n=2
m=1
k=2
i
n=3
m=1
k=2
a和 b为有 10个元素的整型数组比较两数组对应元素变量 n,m,k记录 a[i]>b[i],a[i]==b[i],
a[i]<b[i]的个数最后 若 n>k,认为数组 a>b
若 n<k,认为数组 a<b
若 n==k,认为数组 a==b
#include <stdio.h>
main()
{ int a[10],b[10],i,n=0,m=0,k=0;
printf("Enter array a:\n");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
printf("Enter array b:\n");
for(i=0;i<10;i++)
scanf("%d",&b[i]);
for(i=0;i<10;i++)
{ if(large(a[i],b[i])==1) n=n+1;
else if(large(a[i],b[i])==0) m=m+1;
else k=k+1;
}
/* Output */
}
int large(int x,int y)
{ int flag;
if(x>y) flag=1;
else if(x<y) flag=-1;
else flag=0;
return(flag);
}
数组名作函数参数
地址传递
在主调函数与被调函数分别定义数组,且类型应一致
形参数组大小 (多维数组第一维 )可不指定
形参数组名是 地址变量例 求学生的平均成绩
#include <stdio.h>
float average(int stu[10],int n);
void main()
{ int score[10],i;
float av;
printf("Input 10 scores,\n");
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
例 数组元素与 数组名作函数参数比较
1
2
a
调用前
a[0]
a[1]
1
2
a
调用
a[0]
a[1]
1
2
x
y
2
1
x
y
交换
1
2
a
返回
#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("a[0]=%d\na[1]=%d\n",a[0],a[1]);
}
值传递
1
2
a
调用前
1
2
a
x
调用
2
1
a
x
交换
2
1
a
返回
#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("a[0]=%d\na[1]=%d\n",a[0],a[1]);
}
地址传递例 数组元素与 数组名作函数参数比较例 数组排序 ----简单选择排序
void sort(int array[],int n)
{ int i,j,k,t;
for(i=0;i<n-1;i++)
{ k=i;
for(j=i+1;j<n;j++)
if(array[j]<array[k]) k=j;
if(k!=i)
{ t=array[i];
array[i]=array[k];
array[k]=t;
}
}
}
main()
{ int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
sort(a,10);
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("\n");
}
0
1
2
3
4
5
6
7
8
9
a 49
68
57
32
9
99
27
13
76
88
array kj
j
j k
j k
j
j
j
j
j
9
49
i=0
例 数组排序 ----简单选择排序
void sort(int array[],int n)
{ int i,j,k,t;
for(i=0;i<n-1;i++)
{ k=i;
for(j=i+1;j<n;j++)
if(array[j]<array[k]) k=j;
if(k!=i)
{ t=array[i];
array[i]=array[k];
array[k]=t;
}
}
}
main()
{ int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
sort(a,10);
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("\n");
}
k
j
j k
j
kjj
j
j
j
0
1
2
3
4
5
6
7
8
9
a 49
68
57
32
9
99
27
13
76
88
array 9
49
k
k
13
68
i=1
0
1
2
3
4
5
6
7
8
9
a 9
13
27
32
49
57
68
76
88
99
array
i=8
例 数组排序 ----简单选择排序
void sort(int array[],int n)
{ int i,j,k,t;
for(i=0;i<n-1;i++)
{ k=i;
for(j=i+1;j<n;j++)
if(array[j]<array[k]) k=j;
if(k!=i)
{ t=array[i];
array[i]=array[k];
array[k]=t;
}
}
}
main()
{ int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
sort(a,10);
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("\n");
}
例 求二维数组中最大元素值
1 3 5 7
2 4 6 8
15 17 34 12
i
j
max=1
1 3 5 7
2 4 6 8
15 17 34 12
i
j
max=3
1 3 5 7
2 4 6 8
15 17 34 12
i
j
max=5
j
1 3 5 7
2 4 6 8
15 17 34 12
i
max=7
j
1 3 5 7
2 4 6 8
15 17 34 12
i
max=8
j
1 3 5 7
2 4 6 8
15 17 34 12i
max=34
int max_value(int array[3][4])
{ int i,j,k,max;
max=array[0][0];
for(i=0;i<3;i++)
for(j=0;j<4;j++)
if(array[i][j]>max)
max=array[i][j];
return(max);
}
main()
{ int a[3][4]={{1,3,5,7},
{2,4,6,8},{15,17,34,12}};
printf("max value is %d\n",max_value(a));
}
多维形参数组第一维维数可省略,第二维必须相同
int array[][4]
§ 8.8 变量的存储属性
概述
变量是对程序中数据的存储空间的抽象 内存
…….
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中有效
不同函数中同名变量，占不同内存单元
形参属于局部变量
可定义在复合语句中有效的变量
局部变量可用存储类型,auto register static
（ 默认为 auto）
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:a=%d,b=%d\n",a,b);
sub();
printf("main:a=%d,b=%d\n",a,b);
}
sub()
{ int a,b;
a=6;
b=7;
printf("sub:a=%d,b=%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;
t 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]);
}
例 不同函数中同名变量
main()
{ int a,b;
a=3;
b=4;
printf("main:a=%d,b=%d\n",a,b);
sub();
printf("main:a=%d,b=%d\n",a,b);
}
sub()
{ int a,b;
a=6;
b=7;
printf("sub:a=%d,b=%d\n",a,b);
}
运行结果：
main:a=3,b=4
sub:a=6,b=7
main:a=3,b=4
全局变量 ---外部变量
定义：在 函数外定义,可为 本文件所有函数共用
有效范围：从 定义变量的位置开始 到本源文件结束，及有
extern说明 的其它源文件应尽量少使用全局变量，因为：
全局变量在程序全部执行过程中占用存储单元
降低了函数的通用性、可靠性，可移植性
降低程序清晰性，容易出错定义 说明
次数,只能 1次 可说明多次
位置,所有函数之外 函数内或函数外
分配内存,分配内存,可初始化 不分配内存,不可初始化
>
>
> >
>
>
外部变量说明,extern 数据类型 变量表；
外部变量定义与外部变量说明不同
若外部变量与局部变量同名，则外部变量被屏蔽
外部变量可用存储类型,缺省 或 static
float max,min;
float average(float array[],int n)
{ int i; float sum=array[0];
max=min=array[0];
for(i=1;i<n;i++)
{ if(array[i]>max) max=array[i];
else if(array[i]<min) min=array[i];
sum+=array[i];
}
return(sum/n);
}
main()
{ int i; float ave,score[10];
/*Input */
ave=average(score,10);
printf("max=%6.2f\nmin=%6.2f\n
average=%6.2f\n",max,min,ave);
}
作用域
max
min
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;
/*ch8_16.c*/
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
动态变量与静态变量
存储方式
静态存储：程序运行期间分配固定存储空间
动态存储：程序运行期间根据需要动态分配存储空间
内存用户区程序区静态存储区动态存储区全局变量、局部静态变量形参变量局部动态变量（ auto register)
函数调用现场保护和返回地址等
生存期
静态变量,从程序开始执行到程序结束
动态变量,从包含该变量定义的函数开始执行至函数执行结束
变量存储类型静态动态存储方式程序整个运行期间函数调用开始至结束生存期编译时赋初值,只赋一次每次函数调用时赋初值自动赋初值 0或空字符不确定未赋初值静态存储区动态区存储区 寄存器局部变量 外部变量作用域 定义变量的函数或复合语句内 本文件 其它文件
局部变量默认为 auto型
register型变量个数受限,且不能为 long,double,float型
局部 static变量具有 全局寿命 和 局部可见性
局部 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
例 变量的寿命与可见性
#include <stdio.h>
int i=1;
main()
{ static int a;
register int b=-10;
int c=0;
printf("-----MAIN------\n");
printf("i:%d a:%d \
b:%d c:%d\n",i,a,b,c);
c=c+8;
other();
printf("-----MAIN------\n");
printf("i:%d a:%d \
b:%d c:%d\n",i,a,b,c);
i=i+10;
other();
}
other()
{ static int a=2;
static int b;
int c=10;
a=a+2; i=i+32; c=c+5;
printf("-----OTHER------\n");
printf("i:%d a:%d \
b:%d c:%d\n",i,a,b,c);
b=a;
}
-------Main------
i:1 a:0 b:-10 c:0
------Other------
i:33 a:4 b:0 c:15
-------Main-----
i:33 a:0 b:-10 c:8
-------Other-------
i:75 a:6 b:4 c:15
全局 i 1
main,a 0
b:-10register
main:c 0
静态存储区动态存储区
other,a 2
other,b 0
other,c 10
8
4
33
15
4
43
6
75
6
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;
printf("Enter the number a and its power:\n");
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);
}
§ 8.1 概述
模块化程序设计
基本思想：将一个大的程序按功能分割成一些小模块,
特点：
各模块相对独立、功能单一、结构清晰、接口简单
控制了程序设计的复杂性
提高元件的可靠性
缩短开发周期
避免程序开发的重复劳动
易于维护和功能扩充
开发方法,自上向下,逐步分解，分而治之
C是模块化程序设计语言源程序文件1
预编译命令说明部分 执行部分函数1 函数n
源程序文件i 源程序文件n
C程序
C程序结构
C是 函数式 语言
必须有且只能有一个名为 main的主函数
C程序的执行总是 从 main函数开始，在 main中结束
函数 不能嵌套定义,可以 嵌套 调用
函数分类
从用户角度
标准函数（库函数）：由系统提供
用户自定义函数
从函数形式
无参函数
有参函数使用 库函数 应注意：
1、函数功能
2、函数参数的数目和顺序，及各参数意义和类型
3、函数返回值意义和类型
4、需要使用的包含文件
§ 8.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”); }
函数类型 函数名（形参表）
形参类型说明
{
说明部分语句部分
}
传统风格,
例 有参函数（传统风格）
int max(x,y)
int x,y;
{ int z;
z=x>y?x:y;
return(z);
}
§ 8.3 函数的返回值
返回语句
形式,return(表达式 )；
或 return 表达式 ;
或 return;
功能：使程序控制从被调用函数返回到调用函数中，
同时把返值带给调用函数
说明：
函数中可有多个 return语句
若无 return语句，遇 }时，自动返回调用函数
若函数类型与 return语句中表达式值的类型不一致，按前者为准，自动转换 ------函数调用转换
void型函数例 无返回值函数
void swap(int x,int y )
{ int temp;
temp=x;
x=y;
y=temp;
}
printstar()
{ printf("**********");
}
main()
{ int a;
a=printstar();
printf("%d",a);
}
例 函数带回不确定值输出,10
void printstar()
{ printf("**********");
}
main()
{ int a;
a=printstar();
printf("%d",a);
}
编译错误！
例 函数返回值类型转换
main()
{ 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);
}
§ 8.4 函数的调用
调用形式函数名 (实参表 );
说明：
实参与形参 个数相等,类型一致,按顺序一一对应
实参表求值顺序，因系统而定（ Turbo C 自右向左 ）
main()
{ int i=2,p;
p=f(i,++i);
printf("%d",p);
}
int f(int a,int b)
{ int c;
if(a>b) c=1;
else if(a==b) c=0;
else c=-1;
return(c);
}
例 参数求值顺序
main()
{ int i=2,p;
p=f(i,i++);
printf("%d",p);
}
int f(int a,int b)
{ int c;
if(a>b) c=1;
else if(a==b) c=0;
else c=-1;
return(c);
}
运行结果,0 运行结果,1
调用方式
函数语句：
例 printstar();
printf(“Hello,World!\n”);
函数表达式：
例 m=max(a,b)*2;
函数参数：
例 printf(“%d”,max(a,b));
m=max(a,max(b,c));
函数说明
对被调用函数要求：
必须是 已存在 的函数
库函数,#include <*.h>
用户自定义函数,函数类型说明
函数说明
一般形式,函数类型 函数名 (形参类型 [形参名 ],….,);
或 函数类型 函数名 ();
作用：告诉编译系统 函数类型、参数个数及类型，以便检验
函数定义 与 函数说明 不同
函数说明位置,程序的数据说明部分（函数内或外）
下列情况下，可不作函数说明
若函数返值是 char或 int型,系统自动按 int型处理
被调用函数定义出现在主调函数之前
有些系统 (如 Borland C++)要求函数说明指出函数返值类型和形参类型，并且对 void 和 int 型函数也要进行函数说明例 函数说明举例
main()
{ 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);
}
int型函数可不作函数说明
（ Borland C++不行）
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);
}
被调函数出现在主调函数之前，不必函数说明
/*ch8_5.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();
§ 8.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);
}
形参实参
说明：
实参必须有确定的值
形参必须指定类型
形参与实参 类型一致，个数相同
若形参与实参类型不一致，自动按形参类型转换 ———函数调用转换
形参在函数被调用前不占内存 ;函数调用时为形参分配内存；
调用结束，内存释放
§ 8.5 函数参数及其传递方式
形参与实参
形式参数：定义函数时函数名后面括号中的变量名
实际参数：调用函数时函数名后面括号中的表达式例 计算 x的立方
#include <stdio.h>
float cube(float x)
{ return(x*x*x);
}
main()
{ float a,product;
printf("Please input value of a:");
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:
例 交换两个数
/*ch7_2.c*/
#include <stdio.h>
main()
{ int x=7,y=11;
printf("x=%d,\ty=%d\n",x,y);
printf("swapped:\n");
swap(x,y);
printf("x=%d,\ty=%d\n",x,y);
}
swap(int a,int b)
{ int temp;
temp=a; a=b; b=temp;
}
调用：
7 11a,b:
7 11x,y:
swap,7 11x,y:
11 7a,b:
temp
§ 8.6 函数的嵌套与递归调用
嵌套调用
C规定,函数定义不可嵌套,但 可以嵌套调用 函数
main( )
调用函数 a
结束
a函数 b函数调用函数 b
例 求三个数中最大数和最小数的差值
#include <stdio.h>
int dif(int x,int y,int z);
int max(int x,int y,int z);
int min(int x,int y,int z);
void main()
{ int a,b,c,d;
scanf("%d%d%d",&a,&b,&c);
d=dif(a,b,c);
printf("Max-Min=%d\n",d);
}
Ch7_202.c
int dif(int x,int y,int z)
{ return max(x,y,z)-min(x,y,z); }
int max(int x,int y,int z)
{ int r;
r=x>y?x:y;
return(r>z?r:z);
}
int min(int x,int y,int z)
{ int r;
r=x<y?x:y;
return(r<z?r:z);
}main( )
调用函数 dif
输出结束
dif函数 max函数调用函数 max
调用函数 min min函数例 用弦截法求方程根 080165 23 xxx
x
y
f(x)
0
x1
x2
x
f(x1)
f(x2)
)()(
)()(
12
1221
xfxf
xfxxfxx
求 f(x1)与 f(x2)连线与 x轴的交点 x
输入 x1,x2,求 f(x1),f(x2)
直到 f(x1)与 f(x2)异号
y=f(x),y1=f(x1)
y与 y1同号真 假
x1=x
y1=y
x2=x
直到 |y|<?
root=x 输出 root
root函数运行情况：
Input x1,x2:
2,6?
A root of equation is 5.0000
main( )
调用函数 root
输出根 x
结束
root函数 xpoint函数调用函数 xpoint 调用函数 f
f函数
递归调用
定义：函数直接或间接的调用自身叫函数的递归调用
f( )
调 f 调 f2 调 f1
f1( ) f2( )
说明
C编译系统对递归函数的自调用次数没有限制
每调用函数一次，在内存堆栈区分配空间，用于存放函数变量、返回值等信息，所以递归次数过多，可能引起堆栈溢出
int f(int x)
{ int y,z;
……
z=f(y);
…….
return(2*z);
}
int f1(int x)
{ int y,z;
……
z=f2(y);
…….
return(2*z);
}
int f2(int t)
{ int a,c;
……
c=f1(a);
…….
return(3+c);
}
例 求 n的阶乘
)1()!1(
)1,0(1!
nnn
nn
/*ch8_8.c*/
#include <stdio.h>
int fac(int n)
{ int f;
if(n<0) printf("n<0,data error!");
else if(n==0||n==1) f=1;
else f=fac(n-1)*n;
return(f);
}
main()
{ int n,y;
printf("Input a integer number:");
scanf("%d",&n);
y=fac(n);
printf("%d! =%15d",n,y);
}
例 Hanoi问题 void move(char getone,char putone){ printf("%c--->%c\n",getone,putone); }
void hanoi(int n,char one,char two,char three)
{ if(n==1) move(one,three);
else
{ hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
}
}
main()
{ int m;
printf("Input the number of disks:");
scanf("%d",&m);
printf("The steps to moving %3d disks:\n",m);
hanoi(m,'A','B','C');
}
D:\fengyi\bkc\power\power.c
A B C
§ 8.7 数组作为函数参数
数组元素作函数实参 ——值传递例 两个数组大小比较
4
3
2
1
0
5
a
56
23
12
10
76
88
4
3
2
1
0
5
b
21
23
43
98
66
54
n=0
m=0
k=0
i
n=0
m=0
k=1
i
n=0
m=1
k=1
i
n=1
m=1
k=1
i
n=1
m=1
k=2
i
n=2
m=1
k=2
i
n=3
m=1
k=2
a和 b为有 10个元素的整型数组比较两数组对应元素变量 n,m,k记录 a[i]>b[i],a[i]==b[i],
a[i]<b[i]的个数最后 若 n>k,认为数组 a>b
若 n<k,认为数组 a<b
若 n==k,认为数组 a==b
#include <stdio.h>
main()
{ int a[10],b[10],i,n=0,m=0,k=0;
printf("Enter array a:\n");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
printf("Enter array b:\n");
for(i=0;i<10;i++)
scanf("%d",&b[i]);
for(i=0;i<10;i++)
{ if(large(a[i],b[i])==1) n=n+1;
else if(large(a[i],b[i])==0) m=m+1;
else k=k+1;
}
/* Output */
}
int large(int x,int y)
{ int flag;
if(x>y) flag=1;
else if(x<y) flag=-1;
else flag=0;
return(flag);
}
数组名作函数参数
地址传递
在主调函数与被调函数分别定义数组,且类型应一致
形参数组大小 (多维数组第一维 )可不指定
形参数组名是 地址变量例 求学生的平均成绩
#include <stdio.h>
float average(int stu[10],int n);
void main()
{ int score[10],i;
float av;
printf("Input 10 scores,\n");
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
例 数组元素与 数组名作函数参数比较
1
2
a
调用前
a[0]
a[1]
1
2
a
调用
a[0]
a[1]
1
2
x
y
2
1
x
y
交换
1
2
a
返回
#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("a[0]=%d\na[1]=%d\n",a[0],a[1]);
}
值传递
1
2
a
调用前
1
2
a
x
调用
2
1
a
x
交换
2
1
a
返回
#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("a[0]=%d\na[1]=%d\n",a[0],a[1]);
}
地址传递例 数组元素与 数组名作函数参数比较例 数组排序 ----简单选择排序
void sort(int array[],int n)
{ int i,j,k,t;
for(i=0;i<n-1;i++)
{ k=i;
for(j=i+1;j<n;j++)
if(array[j]<array[k]) k=j;
if(k!=i)
{ t=array[i];
array[i]=array[k];
array[k]=t;
}
}
}
main()
{ int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
sort(a,10);
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("\n");
}
0
1
2
3
4
5
6
7
8
9
a 49
68
57
32
9
99
27
13
76
88
array kj
j
j k
j k
j
j
j
j
j
9
49
i=0
例 数组排序 ----简单选择排序
void sort(int array[],int n)
{ int i,j,k,t;
for(i=0;i<n-1;i++)
{ k=i;
for(j=i+1;j<n;j++)
if(array[j]<array[k]) k=j;
if(k!=i)
{ t=array[i];
array[i]=array[k];
array[k]=t;
}
}
}
main()
{ int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
sort(a,10);
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("\n");
}
k
j
j k
j
kjj
j
j
j
0
1
2
3
4
5
6
7
8
9
a 49
68
57
32
9
99
27
13
76
88
array 9
49
k
k
13
68
i=1
0
1
2
3
4
5
6
7
8
9
a 9
13
27
32
49
57
68
76
88
99
array
i=8
例 数组排序 ----简单选择排序
void sort(int array[],int n)
{ int i,j,k,t;
for(i=0;i<n-1;i++)
{ k=i;
for(j=i+1;j<n;j++)
if(array[j]<array[k]) k=j;
if(k!=i)
{ t=array[i];
array[i]=array[k];
array[k]=t;
}
}
}
main()
{ int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
sort(a,10);
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("\n");
}
例 求二维数组中最大元素值
1 3 5 7
2 4 6 8
15 17 34 12
i
j
max=1
1 3 5 7
2 4 6 8
15 17 34 12
i
j
max=3
1 3 5 7
2 4 6 8
15 17 34 12
i
j
max=5
j
1 3 5 7
2 4 6 8
15 17 34 12
i
max=7
j
1 3 5 7
2 4 6 8
15 17 34 12
i
max=8
j
1 3 5 7
2 4 6 8
15 17 34 12i
max=34
int max_value(int array[3][4])
{ int i,j,k,max;
max=array[0][0];
for(i=0;i<3;i++)
for(j=0;j<4;j++)
if(array[i][j]>max)
max=array[i][j];
return(max);
}
main()
{ int a[3][4]={{1,3,5,7},
{2,4,6,8},{15,17,34,12}};
printf("max value is %d\n",max_value(a));
}
多维形参数组第一维维数可省略,第二维必须相同
int array[][4]
§ 8.8 变量的存储属性
概述
变量是对程序中数据的存储空间的抽象 内存
…….
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中有效
不同函数中同名变量，占不同内存单元
形参属于局部变量
可定义在复合语句中有效的变量
局部变量可用存储类型,auto register static
（ 默认为 auto）
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:a=%d,b=%d\n",a,b);
sub();
printf("main:a=%d,b=%d\n",a,b);
}
sub()
{ int a,b;
a=6;
b=7;
printf("sub:a=%d,b=%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;
t 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]);
}
例 不同函数中同名变量
main()
{ int a,b;
a=3;
b=4;
printf("main:a=%d,b=%d\n",a,b);
sub();
printf("main:a=%d,b=%d\n",a,b);
}
sub()
{ int a,b;
a=6;
b=7;
printf("sub:a=%d,b=%d\n",a,b);
}
运行结果：
main:a=3,b=4
sub:a=6,b=7
main:a=3,b=4
全局变量 ---外部变量
定义：在 函数外定义,可为 本文件所有函数共用
有效范围：从 定义变量的位置开始 到本源文件结束，及有
extern说明 的其它源文件应尽量少使用全局变量，因为：
全局变量在程序全部执行过程中占用存储单元
降低了函数的通用性、可靠性，可移植性
降低程序清晰性，容易出错定义 说明
次数,只能 1次 可说明多次
位置,所有函数之外 函数内或函数外
分配内存,分配内存,可初始化 不分配内存,不可初始化
>
>
> >
>
>
外部变量说明,extern 数据类型 变量表；
外部变量定义与外部变量说明不同
若外部变量与局部变量同名，则外部变量被屏蔽
外部变量可用存储类型,缺省 或 static
float max,min;
float average(float array[],int n)
{ int i; float sum=array[0];
max=min=array[0];
for(i=1;i<n;i++)
{ if(array[i]>max) max=array[i];
else if(array[i]<min) min=array[i];
sum+=array[i];
}
return(sum/n);
}
main()
{ int i; float ave,score[10];
/*Input */
ave=average(score,10);
printf("max=%6.2f\nmin=%6.2f\n
average=%6.2f\n",max,min,ave);
}
作用域
max
min
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;
/*ch8_16.c*/
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
动态变量与静态变量
存储方式
静态存储：程序运行期间分配固定存储空间
动态存储：程序运行期间根据需要动态分配存储空间
内存用户区程序区静态存储区动态存储区全局变量、局部静态变量形参变量局部动态变量（ auto register)
函数调用现场保护和返回地址等
生存期
静态变量,从程序开始执行到程序结束
动态变量,从包含该变量定义的函数开始执行至函数执行结束
变量存储类型静态动态存储方式程序整个运行期间函数调用开始至结束生存期编译时赋初值,只赋一次每次函数调用时赋初值自动赋初值 0或空字符不确定未赋初值静态存储区动态区存储区 寄存器局部变量 外部变量作用域 定义变量的函数或复合语句内 本文件 其它文件
局部变量默认为 auto型
register型变量个数受限,且不能为 long,double,float型
局部 static变量具有 全局寿命 和 局部可见性
局部 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
例 变量的寿命与可见性
#include <stdio.h>
int i=1;
main()
{ static int a;
register int b=-10;
int c=0;
printf("-----MAIN------\n");
printf("i:%d a:%d \
b:%d c:%d\n",i,a,b,c);
c=c+8;
other();
printf("-----MAIN------\n");
printf("i:%d a:%d \
b:%d c:%d\n",i,a,b,c);
i=i+10;
other();
}
other()
{ static int a=2;
static int b;
int c=10;
a=a+2; i=i+32; c=c+5;
printf("-----OTHER------\n");
printf("i:%d a:%d \
b:%d c:%d\n",i,a,b,c);
b=a;
}
-------Main------
i:1 a:0 b:-10 c:0
------Other------
i:33 a:4 b:0 c:15
-------Main-----
i:33 a:0 b:-10 c:8
-------Other-------
i:75 a:6 b:4 c:15
全局 i 1
main,a 0
b:-10register
main:c 0
静态存储区动态存储区
other,a 2
other,b 0
other,c 10
8
4
33
15
4
43
6
75
6
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;
printf("Enter the number a and its power:\n");
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);
}
