数组与函数

数组

数组是有序的元素序列，简单点说就是存放数据的容器；数组一旦创建是不可更改的；数组中的元素在内存中是连续依次排列的。

如

int a[100];

表示定义了一个有100个单元的数组a。即a[0] a[1] a[2]…a[99]且每个单元都是int变量。

数组的每个单元就是数组类型的一个变量

例1：计算用户输入的数字的平均数，并输出所有大于平均数的数

//数组计算平均数

#include

int main(){

int x;

double sum =0;

int cnt =0;

int y[100];//定义数组

printf("输入一系列的数：");

scanf("%d",&x);

while(x!=-1){

y[cnt]=x;//对数组中的元素赋值

sum+=x;

cnt++;

scanf("%d",&x);

}

printf("平均数为：%lf \n",sum/cnt);

if(cnt>0){

int i;

int ave=sum/cnt;

for(i=0;i

if(y[i]>ave){//使用数组中的元素

printf("%d \n",y[i]);//遍历数组

}

}

}

}

}

先定义数组 y[100]意思是y这个数组中可以放100个int。

输入X值，进入white循环以x=-1结束循环

让y[cnt]=x意思是让y数组的cnt位置上那个单元等于x,然后cnt递增

用sum记录每次输入的x值的和。

进入if判断语句cnt>0执行｛｝里的语句，cnt<=0则直接结束。

定义变量i 与ave,然后设置循环 i=0; i如果y[i]>ave(平均数)则直接输出大于平均数的所有的数值。

当然这个程序还是存在安全隐患，存在的安全隐患就在于如果y[cnt]里的cnt大于定义数组所最大承受的数值 即数组越界。

例2：用数组实现一组数的倒序输出，以输入-1结束。

//用数组实现一组数的倒序输出

#include

int main(){

int i,x,z,w,c; //定义变量

int a[100];//定义一个大小为100的数组a

int d[100];//定义一个大小为100的数组d

printf("输入数的个数不大于100：");

scanf("%d",&x);//键盘输入数的个数

for(i=1;i<=x;i++){//初始化数组a

a[i]=0;

}

printf("输入数以-1结束:");

scanf("%d",&z);//键盘输入数

i=0;//设i的初值为0

while (z!=-1)//设置循环判断条件当输入数为-1时结束循环

{

i++;//把输入的数加入到初始化的数组a

a[i]=z;

scanf("%d",&z);

}

w=i;//把上个循环累加后的i值赋值给w

printf("倒序输出如下：");

for( c=1;c<=w;){

d[c]=a[i];//把a数组的最后一位的数值赋值给d数组的第一位

i--;//i递减

printf("%d \t",d[c]);//依次输出d数组里的值

c++;//c递增

}

}

函数的定义与使用

函数是C语言程序中的一种基本组成部分，C语言程序的功能是通过函数之间的调用来实现的，一个完整的C语言程序可由一个或多个函数组成。

例1.求和函数

//求和

#include

void qh(int y, int c){

int x=0;

int i;

for(i=y;i<=c;i++){

x=x+i;

}

printf("%d-%d累加为：%d \n",y,c,x);

}

int main(){

qh(1,10);

qh(10,20);

qh(20,30);

qh(30,35);

qh(35,45);

}

注：

一个C程序中有且只有一个main主函数。无论是main()在程序中的什么位都是最先执行的。

一个c程序可以由一个主函数和多个函数组成如例子。、

C语言中函数与函数之间都是相互独立的，不能定义嵌套。

除主函数外，函数都是通过调用来执行的，即使程序中定义了函数，未调用时也不能执行，尤其注意，任何函数不可调用主函数。

定义函数必须先定义后使用，程序中的qh函数就是自定义函数。

main()主函数中的 qh 函数调用。

函数定义

函数定义格式：

[存储类型][类型说明]函数名([形式参数说明列表])

{

说明部分

语句部分(函数体部分)

}

注：

函数名是唯一标识一个函数的字符串，它的命名规则同变量一样。

当有返回值时，要在函数加一个返回值说明 return(？)。

形参说明之间必须要用逗号隔开。

函数体，由说明部分和语句部分组成。

例2：求给定值x的阶乘的函数

long fa(int x)/*函数头*/{//大括号里叫函数体

long y;

for(y=1;x>0;--x)

y=y*xl

return(y);

}

函数调用

格式：

函数名([实参列表]);

注:

实参列表中的所有东西必须与函数定义时完全一致，当有多个实参时，相互之间需用逗号隔开。

实参的量可以是常量、有值的变量或者运算表达式。

()起到了表示函数调用的重要作用

即使没有参数也要加。

例1：实参求值顺序举例

#include

void main(){

int i,n;

n=f(i=0,i++);

printf("\n n=%d \t",n);

}

f(int i,int a){

int c;

if(i>a)

c=2;

else

c=1;

return(c);

}

首先计算每一个实参表达式的值，并把此值存入所对应的形参单元中。

执行流程转入函数体，执行函数体中的各语句。

函数体执行之后，return(c)返回到调用该函数的函数中的调用处的下一条语句去执行。

函数调用的方式

以函数调用语句形式调用

例1

f();

以函数表达式的一个运算对象形式调用

例2

k=f(m,n)*k(i,j);

以函数调用中的一个实际参数形式调用

例3

k=f(f(m,n),j);

printf("%d",power(a,b));

对被调用函数的使用说明

在程序中调用另一个函数，要满足三个条件：

调用的函数可以是库函数或者自定义函数。

如果是库函数要用#include命令

如果是自定义函数，且该函数与自定义函数在同一个源文件中，则在调用函数中应对被调用函数返回值的类型加以说明，说明格式如下：

类型说明符 被调用函数名();

函数的返回值

函数调用的目的通常是为了得到一个计算结果，利用返回语句return将计算结果返回给调用程序，同时，也使程序的执行流程转到调用语句的下一语句去执行。

返回语句结构：

return(表达式)；

或者return 表达式 ；

例1

//return的使用

#include

int max(int a,int c){

int x;

if(a>c){

x=a;

}else{

x=c;

}

return x;

}

int main()

{

int a,c,x;

printf("输入两个数字：");

scanf("%d%d",&a,&c);

x=max(a,c);

printf("%d \n",x);

}

本地变量

函数的每一次运行，就产生了一个独立的变量空间，在这个空间中的变量，是函数的这次运行所独有的，称为本地变量

定义在函数内部的变量就是本地变量

参数也是本地变量

(1)变量的生存期和作用域

生存期：什么时候开始到什么灭亡

作用域：在什么范围可以访问这个变量

对于本地变量，这两个问题的答案是统一的：大括号内——块

例如：

#include

int swap(int a,int b);

int main()

{

int a = 5;

int b = 6;

int i;

swap(a,b);

printf("%d-%d\n", a, b);

return 0;

}

int swap(int a, int b)

{

int t = a;

a = 8;

b = 9;

return a,b;

}

main函数与swap函数的变量空间是相对独立的，当程序执行到swap(a,d)；时直接去swap 的变量空间，注意当离开main的变量空间时 a ,b并不会因为离开main函数而消亡，到了swap函数执行swap变量空间的语句完成后返回main的变量空间，这时候的swap函数已经结束就不存在了，此时a,b的值还是以前的main函数的值没有改变，所以输出5-6

(2)本地变量规则

本地变量是定义在块内的

它可以是定义在函数的块内

也可以定义在语句的块内

程序运行进入这个块之前，其中的变量不存在，离开这个块，其中的变量就消失了

块外面定义的变量在里面依然有效

块里面定义了和外面同名的变量则掩盖了外面的(例3)

不能在一个块内定义同名的变量

本地变量不会被默认初始化

例2

#include

int swap(int a,int b);

int main()

{

int a = 5;

int b = 6;

swap(a,b);

if(a

int i=0;

printf("%d",i);

}

else{

{

int a=3;

int b=4;

printf("%d-%d\n", a, b);

}

}

return 0;

}

int swap(int a, int b)

{

int t = a;

a = 8;

b = 9;

return a,b;

}

注意

i的作用域仅限if-else 在此之外不起任何作用，而它生存期也是却决ab的时候i不存在，如果(a>d)i的生成期开始，结束if，i的生存期反之灭亡。

例3

int main()

{

int a = 5;

int b = 6;

if(a>b){

int i=0;

printf("%d",i);

}

else{

{

int a=3;

int b=4;

printf("%d-%d\n", a, b);

}

}

return 0;

}

函数参数及函数间的数据传递

在函数定义时，函数名后面圆括号内的参数称为形式参数，简称形参。格式为：

int k(int a,int b)

注意

(int a,int b)中的int是不能删除的！！！！！

在函数调用时，函数名后的面圆括号内的参数称为实际参数。实参可以是常量、已赋值的变量或者表达式。C语言中传递实参的值有两种方式。第一种是“值的传递”，调用函数将实参的值传递到被调用的函数形参设置的临时变量存储空间，被调用函数形参值的改变对调用函数的实参没有影响。结束后，形参存储单元被释放，实参保持不变。即为单向传递。另一种为“地址传递”，就是当实参为数组名、指针变量或地址表达式时，形参与实参间的传递是双向传递。

例如：

#include

int main()

{

void f(int b[ ]);

int a[10],i;

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

scanf("%d",&a[i]);

f(a);

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

printf("\n%4d",a[i]);

}

void f(int b []){

int max,max_i,i;

max=b[0],max_i=0;

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

if(max

{

max=b[i];

max_i=i;

}

max=b[0];

b[0]=b[max_i];

b[max_i]=max;

return;

}

地址传递特点，被传递的数据在被调用函数中对存储空间的值做出某种变动后，必然会影响到使用该空间的调用函数的变量值。

因此参数传递可以归纳为非数组名作为函数参数和数组名作为函数参数传递·

函数的嵌套调用和递归调用

1. 函数的嵌套调用

在上面说过函数是相互独立的，函数和函数之间没有从属关系，即一个函数内不能包括另一个函数的定义。一个函数可以被多个函数调用这就是函数的嵌套使用，这里要和选择嵌套与循环嵌套区分开来，函数的嵌套不是写在一个函数里面的，而是相互独立的写法。

2. 函数的递归调用

递归调用，就是在调用一个函数过程中又出现直接或间接地调用该函数本身。

直接递归调用

就是调用这个函数的本身。例如：

float func(int n)

{

int m;

float f;

...

f=func(m);

}

间接递归调用

就是函数可间接地调用函数本身。例如：

funcl(int n)

{

int m;

...

func2(m);

...

}

func2(int x)

{

int y;

...

funcl(y);

}

内部函数和外部函数

内部函数

只能在定义它的文件中被调用的函数。定义内部函数只需要在函数定义的前面冠以static说明符，即

static 类型标识符 函数名

例如：

static float k(int a, int b){

....

}

外部函数

在函数定义的前面冠以extern说明符的函数 即

extern 类型标识符 函数名

注意

在定义函数时省去了 extern说明符时，则隐含外部函数

在需要调用外部函数的文件中，应该用extern说明所用的函数是外部函数