C 函数

函数的概述

C 程序是由函数组成的，我们写的代码都是由主函数 main()开始执行的。函数是 C 程序的基本模块，是用于完成特定任务的程序代码单元。

从函数定义的角度看，函数可分为系统函数和用户定义函数两种：
(1)系统函数，即库函数：这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用它们，如我们常用的打印函数printf()。

(2)用户定义函数：用以解决用户的专门需要。

为什么要使用函数呢？

1）函数的使用可以省去重复代码的编写。

如果程序中需要多次使用某种特定的功能( 求两个数的最大值 )，直接写在main()里，代码的重复率很比较高，同时，代码给人的感觉会很冗余，如下：

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. int main()  
4. {  
5.     // 操作1 ……  
6.     // ……  
7.     int a1 = 10, b1 = 20, c1 = 0;  
8.     if(a1 > b1){  
9.         c1 = a1;  
10.     }else{  
11.         c1 = b1;  
12.     }  
13.       
14.     // 操作2 ……  
15.     // ……  
16.     int a2 = 11, b2 = 21, c2 = 0;  
17.     if(a2 > b2){  
18.         c2 = a2;  
19.     }else{  
20.         c2 = b2;  
21.     }  
22.       
23.     // ……  
24.       
25.     return 0;  
26. }  

使用函数后，降低代码的重复率，如下：

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. // 求两数的最大值  
4. int max(int a, int b)  
5. {  
6.     if(a > b){  
7.         return a;  
8.     }else{  
9.         return b;  
10.     }  
11. }  
12.   
13. int main()  
14. {  
15.     // 操作1 ……  
16.     // ……  
17.     int a1 = 10, b1 = 20, c1 = 0;  
18.     c1 = max(a1, b1); // 调用max()  
19.       
20.     // 操作2 ……  
21.     // ……  
22.     int a2 = 11, b2 = 21, c2 = 0;  
23.     c2 = max(a2, b2); // 调用max()  
24.       
25.     // ……  
26.       
27.     return 0;  
28. }  

2）函数可以让程序更加模块化，从而有利于程序的阅读，修改和完善。

假如我们编写一个实现以下功能的程序：读入一行数字；对数字进行排序；找到它们的平均值；打印出一个柱状图。

如果我们把这些操作直接写在main()里，这样可能会给用户感觉代码会有点凌乱。但，假如我们使用函数，这样可以让程序更加清晰、模块化。

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. int main()  
4. {  
5.     float list[50];  
6.       
7.     // 这里只是举例，函数还没有实现  
8.     readlist(list,50);  
9.     sort(list,50);  
10.     average(list,50);  
11.     bargraph(list,50);  
12.   
13.     return 0;  
14. }  

这里我们可以这么理解，程序就像公司，公司是由部门组成的，这个部门就类似于C程序的函数。默认情况下，公司就是一个大部门( 只有一个部门的情况下 )，相当于C程序的main()函数。如果公司比较小( 程序比较小 )，因为任务少而简单，一个部门即可( main()函数 )胜任。但是，如果这个公司很大( 大型应用程序 )，任务多而杂，如果只是一个部门管理( 相当于没有部门，没有分工 )，我们可想而知，公司管理、运营起来会有多混乱，不是说这样不可以运营，只是这样不完美而已，如果根据公司要求分成一个个部门( 根据功能封装一个一个函数 )，招聘由行政部门负责，研发由技术部门负责等，这样就可以分工明确，结构清晰，方便管理，各部门之间还可以相互协调。

接下来我们一起学习函数：函数的定义，函数的调用，函数的声明。

函数的定义

函数定义的一般形式：

返回类型 函数名( 形式参数列表 )

{

数据定义部分;

执行语句部分;

}

例子如下图：

这里还有几点说明：

1）函数名：理论上是可以随意起名字，最好起的名字见名知意，应该让用户看到这个函数名字就知道这个函数的功能。注意，函数名的后面有个圆换号()，代表这个为函数，不是普通的变量名。

2）形参列表：在定义函数时指定的形参，在未出现函数调用时，它们并不占内存中的存储单元，因此称它们是形式参数或虚拟参数，简称形参，表示它们并不是实际存在的数据，所以，形参里的变量不能赋值。

[cpp]  view plain  copy

1. int max(int a = 10, int b = 20) // error, 形参不能赋值  
2. {  
3.   
4. }  

在定义函数时指定的形参，必须是，类型+变量的形式：

[cpp]  view plain  copy

1. ///1: right, 类型+变量  
2. int max(int a, int b)  
3. {  
4.   
5. }  
6.   
7. ///2: error, 只有类型，没有变量  
8. int max(int, int)  
9. {  
10.   
11. }  
12.   
13. ///3: error, 只有变量，没有类型  
14. int a, int b;  
15. int max(a, b)  
16. {  
17.   
18. }  

在定义函数时指定的形参，可有可无，根据函数的需要来设计，如果没有形参，圆括号内容为空，或写一个void关键字：

[cpp]  view plain  copy

1. // 没形参， 圆括号内容为空  
2. int max()  
3. {  
4.   
5. }  
6.   
7. // 没形参， 圆括号内容为void关键字  
8. int max(void)   
9. {  
10.   
11. }  

3）函数体：花括号{ }里的内容即为函数体的内容，这里为函数功能实现的过程，这和以前的写代码没太大区别，以前我们把代码写在main()函数里，现在只是把这些写到别的函数里。

4）返回类型：函数的值是指函数被调用之后，执行函数体中的程序段所取得的并返回给主调函数的值。函数的返回值是通过函数中的return语句获得的，return后面的值也可以是一个表达式。

a)尽量保证return语句中表达式的值和函数返回类型是同一类型。

[cpp]  view plain  copy

1. int max() // 函数的返回值为int类型  
2. {  
3.     int a = 10;  
4.     return a;// 返回值a为int类型，函数返回类型也是int，匹配  
5. }  

b)如果函数返回的类型和return语句中表达式的值不一致，则以函数返回类型为准，即函数返回类型决定返回值的类型。对数值型数据，可以自动进行类型转换。

[cpp]  view plain  copy

1. int max() // 函数的返回值为int类型  
2. {  
3.     double a = 10.1f;  
4.     return a;// 返回值a为double类型，它会转为int类型(a = 10)再返回  
5. }  

如果函数返回的类型和return语句中表达式的值不一致，而它又无法自动进行类型转换，程序则会报错。

c)return语句的另一个作用为中断return所在的执行函数，类似于break中断循环，switch语句一样。

[cpp]  view plain  copy

1. int max()  
2. {  
3.     return 1;// 执行到，函数已经被中断，所以下面的return 2无法被执行到  
4.     return 2;// 没有执行  
5. }  

d)如果函数带返回值，return后面必须跟着一个值，如果函数没有返回值，函数名字的前面必须写一个void关键字，这时候，我们写代码时也可以通过return中断函数(也可以不用)，只是这时，return后面不带内容( 分号“；”除外)。

[cpp]  view plain  copy

1. void max()// 必须要有void关键字  
2. {  
3.     return; // 中断函数，这个可有可无  
4. }  

函数的调用

定义函数后，我们需要调用此函数才能执行到这个函数里的代码段。这和main()函数不一样，main()为编译器设定好自动调用的主函数，无需人为调用，我们都是在main()函数里调用别的函数，一个 C 程序里有且只有一个main()函数。

我们有这么一个简单程序：

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. int main()  
4. {  
5.     printf("this is for test\n");  
6.       
7.     return 0;  
8. }  

接着，我们将这个打印的操作封装在自定义函数里，这个函数即没返回值，也没形参：

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. void print_test()  
4. {  
5.     printf("this is for test\n");  
6. }  
7.   
8. int main()  
9. {  
10.     print_test();   // print_test函数的调用  
11.       
12.     return 0;  
13. }  

这个程序运行的效果，和上面的是等价的。

程序的执行流程：

1）进入main()函数

2）调用print_test()函数：

a) 它会在main()函数的前寻找有没有一个名字叫“print_test”的函数定义；

b) 如果找到，接着检查函数的参数，这里调用函数时没有传参，函数定义也没有形参，参数类型匹配；

c) 开始执行print_test()函数，这时候，main()函数里面的执行会阻塞( 停 )在print_test()这一行代码，等待print_test()函数的执行。

3）print_test()函数执行完( 这里打印一句话 )，main()才会继续往下执行，执行到return 0, 程序执行完毕。

Ｃ语言中，函数调用的一般形式为：

函数名(实际参数表)

1）实际参数表，常称“实参”， 这里要区别好形参和实参，函数定义时圆括号里的是形参，函数调用时圆括号里的是实参。

a）如果是调用无参函数，则不能加上“实参”，但括号不能省略。

[cpp]  view plain  copy

1. // 函数的定义  
2. void test()  
3. {  
4.   
5. }  
6.   
7. int main()  
8. {  
9.     // 函数的调用  
10.     test(); // right, 圆括号()不能省略  
11.     test(250); // error, 函数定义时没有参数  
12.       
13.     return 0;  
14. }  

b）如果实参表列包含多个实参，则各参数间用逗号隔开。

[cpp]  view plain  copy

1. // 函数的定义  
2. void test(int a, int b)  
3. {  
4.   
5. }  
6.   
7. int main()  
8. {  
9.     int p = 10, q = 20;  
10.     test(p, q); // 函数的调用  
11.       
12.     return 0;  
13. }  

c）实参与形参的个数应相等，类型应匹配(相同或赋值兼容)。实参与形参按顺序对应，一对一地传递数据。

d）实参可以是常量、变量或表达式，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。所以，这里的变量是在圆括号( )外面定义好、赋好值的变量。

[cpp]  view plain  copy

1. // 函数的定义  
2. void test(int a, int b)  
3. {  
4.   
5. }  
6.   
7. int main()  
8. {  
9.     // 函数的调用  
10.     int p = 10, q = 20;  
11.     test(p, q); // right  
12.     test(11, 30-10); // right  
13.       
14.     test(int a, int b); // error, 不应该在圆括号里定义变量  
15.       
16.     return 0;  
17. }  

2）函数的返回值

a）如果函数定义没有返回值，函数调用时不能写void关键字，调用函数时也不能接收函数的返回值。

[cpp]  view plain  copy

1. // 函数的定义  
2. void test()  
3. {  
4.   
5. }  
6.   
7. int main()  
8. {  
9.     // 函数的调用  
10.     test(); // right  
11.     void test(); // error, 函数调用时不能写void关键字  
12.     int a = test(); // error, 函数定义根本就没有返回值  
13.       
14.     return 0;  
15. }  

b）如果函数定义有返回值，这个返回值我们根据用户需要可用可不用，但是，假如我们需要使用这个函数返回值，我们需要定义一个匹配类型的变量来接收。

[cpp]  view plain  copy

1. // 函数的定义, 返回值为int类型  
2. int test()  
3. {  
4.   
5. }  
6.   
7. int main()  
8. {  
9.     // 函数的调用  
10.     int a = test(); // right, a为int类型  
11.     int b;  
12.     b = test(); // right, 和上面等级  
13.       
14.     char *p = test(); // error, p为char *, 函数返回值为int, 类型不匹配  
15.       
16.     int = test();   // error, 必须定义一个匹配类型的变量来接收返回值，  
17.             // int只是类型，没有定义变量  
18.     int test();// error, 必须定义一个匹配类型的变量来接收返回值，  
19.             // int只是类型，没有定义变量  
20.       
21.     return 0;  
22. }  

下面，我们写一个完整例子：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. /**************************** 
3. 功能：求两个数的最大值 
4. 参数： 
5.     x, y: 需要比较的两个整数 
6. 返回值：两个数的最大值 
7. ******************************/  
8. int max(int x, int y)  
9. {  
10.     return x>y ? x : y;  
11. }  
12.   
13. int main()  
14. {  
15.     int a = 10, b = 25, num_max = 0;  
16.     num_max = max(a, b); // 函数的调用  
17.       
18.     printf("num_max = %d\n", num_max);  
19.       
20.     return 0;  
21. }  

当调用max(a, b)时，实参变量(a, b)对形参变量(x, y)的进行数据传递( “值传递” )。只有在发生函数调用时，函数max中的形参这时候才会被分配内存单元，以便接收从实参传来的数据。在调用结束后，形参所占的内存单元也被释放。同时，把函数的返回值赋给main()里的num_max变量。

关于形参和实参的几点说明：

1）形参出现在函数定义中，在整个函数体内都可以使用，离开该函数则不能使用。

2）实参出现在主调函数中，进入被调函数后，实参变量也不能使用。

3）实参变量对形参变量的数据传递是“值传递”，即单向传递，只由实参传给形参，而不能由形参传回来给实参。

4）在调用函数时，编译系统临时给形参分配存储单元。调用结束后，形参单元被释放。

5）实参单元与形参单元是不同的单元。调用结束后，形参单元被释放，函数调用结束返回主调函数后则不能再使用该形参变量。实参单元仍保留并维持原值。因此，在执行一个被调用函数时，形参的值如果发生改变，并不会改变主调函数中实参的值。

函数的声明

在一个函数中调用另一个函数（即被调用函数）需要具备哪些条件呢？

1）首先被调用的函数必须是已经存在的函数。

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. int main()  
4. {  
5.     int a = 10, b = 25, num_max = 0;  
6.     num_max = max(a, b); // 函数的调用，这个函数不存在  
7.       
8.     printf("num_max = %d\n", num_max);  
9.       
10.     return 0;  
11. }  

编译程序会报错：

2）如果使用库函数，包含所需要头文件即可用。

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <string.h> // strlen()所需头文件  
3.   
4. int main()  
5. {  
6.     char *p = "hello, I am mike!"  
7.     int len = strlen(p); // 测字符串的长度  
8.     printf("len = %d\n", len);  
9.       
10.     return 0;  
11. }  

3）如果使用用户自己定义的函数，而该函数与调用它的函数（即主调函数）在文件中，且函数定义的位置在主调函数之后，则必须在调用此函数之前对被调用的函数作声明。

所谓函数声明，就是在函数尚在未定义的情况下，事先将该函数的有关信息通知编译系统，相当于告诉编译器，函数在后面定义，以便使编译能正常进行。

函数声明其一般形式为( 后面的分号不能省略 )：
类型说明符 被调函数名(类型 形参，类型 形参 …)；
或为：
类型说明符 被调函数名(类型，类型 …)；

括号内给出了形参的类型和形参名，或只给出形参类型。这便于编译系统进行检错，以
防止可能出现的错误。

如：
int max(int a,int b);
或写为:
int max(int,int);

完整例子如下：

[cpp]  view plain  copy

1. #include <stdio.h>  
2.   
3. int max(int x, int y); // 函数的声明，分号不能省略  
4. // int max(int, int); // 另一种方式  
5.   
6. int main()  
7. {  
8.     int a = 10, b = 25, num_max = 0;  
9.     num_max = max(a, b); // 函数的调用  
10.       
11.     printf("num_max = %d\n", num_max);  
12.       
13.     return 0;  
14. }  
15.   
16. // 函数的定义  
17. int max(int x, int y)  
18. {  
19.     return x>y ? x : y;  
20. }  

函数定义和定义的区别：

1）定义是指对函数功能的确立，包括指定函数名、函数类型、形参及其类型、函数体等，它是一个完整的、独立的函数单位。

2）声明的作用则是把函数的名字、函数类型以及形参的个数、类型和顺序(注意，不包括函数体)通知编译系统，以便在对包含函数调用的语句进行编译时，据此对其进行对照检查（例如函数名是否正确，实参与形参的类型和个数是否一致）。