第 6 章函数

对应教材目录

6.1 函数的分类和定义
6.2 函数的返回值和参数
6.3 嵌套调用
6.4 变量的作用域
6.5 函数的作用域
6.6 编程实战

本章目标

学完这一章，你应该能做到：

理解函数的作用是“封装功能”。
能自己定义简单函数。
知道形参、实参、返回值的含义。
能使用函数解决重复代码问题。
理解局部变量和全局变量的区别。
初步理解递归和嵌套调用。

1. 为什么要学函数

如果一个程序越来越长，所有代码都写在 main 函数里，会很乱。

函数的作用就是：

把一段独立功能单独封装起来
方便重复使用
让程序更清晰

2. 函数的基本形式

1
返回类型 函数名(参数列表)
2
{
3
    函数体
4
}

例如：

1
int add(int x, int y)
2
{
3
    return x + y;
4
}

3. 函数的定义和调用

完整例子：

1
#include <stdio.h>
2

3
int add(int x, int y)
4
{
5
    return x + y;
6
}
7

8
int main(void)
9
{
10
    int a, b, c;
11
    scanf("%d%d", &a, &b);
12
    c = add(a, b);
13
    printf("%d\n", c);
14
    return 0;
15
}

这里：

add 是函数名
x、y 是形参
a、b 是实参
return x + y; 是返回值

4. 无参和有参

4.1 无参函数

1
void hello(void)
2
{
3
    printf("hello\n");
4
}

这里的 void hello(void) 里其实有两个 void，但它们的意思不一样：

前面的 void：表示这个函数没有返回值。
括号里的 void：表示这个函数没有参数。

也就是说：

1
void hello(void)

可以拆开理解成：

hello 这个函数执行一个动作
不需要传入任何数据
执行完以后也不返回结果

再看一个对比例子：

1
int square(int x)

这里：

前面的 int 表示函数执行后会返回一个整数
括号里的 int x 表示调用这个函数时，要传入一个整型参数 x

还有一个你很容易混淆的点：

hello(void)：明确表示“无参数”，这是标准、清晰的写法。
hello()：在 C 语言里更接近“参数没有写明”，初学阶段不要把它当成严格意义上的“无参函数”写法。

所以以后看到：

int main(void)：表示 main 没有参数，但会返回一个 int
void print_line(void)：表示 print_line 没有参数，也没有返回值

最后看看实际中的效果

20260413174004

20260413174030

可以从图片中看到，第一个是黄色的警告（这个时候代码是可以运行的），第二个是直接报错了（编译不了）。

4.2 有参函数

1
int square(int x)
2
{
3
    return x * x;
4
}

5. 有返回值和无返回值

5.1 有返回值

1
int max(int a, int b)
2
{
3
    return a > b ? a : b;
4
}

5.2 无返回值

1
void print_line(void)
2
{
3
    printf("------\n");
4
}

如果函数只是完成一个动作，不需要把结果交回来，可以使用 void。

这里前面的 void 是“无返回值”，括号里的 (void) 是“无参数”，两个位置的含义不要混在一起。

6. 参数传递

C 语言函数参数传递的基础是值传递。

这意味着：函数接收到的是实参值的副本，不是原变量本身。

例如：

1
#include <stdio.h>
2

3
void change(int x)
4
{
5
    x = 100;
6
}
7

8
int main(void)
9
{
10
    int a = 10;
11
    change(a);
12
    printf("%d\n", a);
13
    return 0;
14
}

输出仍然是：

1
10

因为 change 改的是形参 x，不是 main 里的 a。

7. 函数声明

如果函数定义写在 main 后面，通常要先声明。

1
#include <stdio.h>
2

3
int add(int x, int y);
4

5
int main(void)
6
{
7
    printf("%d\n", add(2, 3));
8
    return 0;
9
}
10

11
int add(int x, int y)
12
{
13
    return x + y;
14
}

8. 局部变量和全局变量

8.1 局部变量

在函数内部定义，只在本函数内有效。

8.2 全局变量

在所有函数外部定义，作用域更大。

示例：

1
#include <stdio.h>
2

3
int a = 100;
4

5
void fun(void)
6
{
7
    int a = 10;
8
    printf("%d\n", a);
9
}
10

11
int main(void)
12
{
13
    fun();
14
    printf("%d\n", a);
15
    return 0;
16
}

这里 fun 中的局部变量 a 会暂时屏蔽全局变量 a。

9. static 局部变量

1
int f(void)
2
{
3
    static int a = 0;
4
    a++;
5
    return a;
6
}

static 局部变量的特点：

只初始化一次
函数调用结束后值不会消失

10. 递归的入门理解

递归就是函数自己调用自己。

例如求阶乘：

1
int fact(int n)
2
{
3
    if (n == 1) {
4
        return 1;
5
    }
6
    return n * fact(n - 1);
7
}

递归一定要有结束条件，否则会无限调用。

11. 本章常见模板

11.1 求最大值函数

1
int max(int a, int b)
2
{
3
    if (a > b) {
4
        return a;
5
    }
6
    else {
7
        return b;
8
    }
9
}

11.2 判断奇偶函数

1
int is_even(int n)
2
{
3
    if (n % 2 == 0) {
4
        return 1;
5
    }
6
    else {
7
        return 0;
8
    }
9
}

11.3 数组求和函数

1
int sum(int a[], int n)
2
{
3
    int i, s = 0;
4
    for (i = 0; i < n; i++) {
5
        s += a[i];
6
    }
7
    return s;
8
}

12. 本章最容易错的点

忘记写函数声明。
把形参和实参混淆。
以为函数中改了参数，外面的原变量也会变。
返回值类型和实际返回内容不匹配。
递归没有结束条件。
局部变量和全局变量重名时判断不清作用范围。

13. 手写题

写结果题

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
int f(int x)
4
{
5
    x = x + 10;
6
    return x;
7
}
8

9
int main(void)
10
{
11
    int a = 5;
12
    f(a);
13
    printf("%d\n", a);
14
    return 0;
15
}

答案：

1
5

解析：

f(a) 调用时，把 a 的值 5 传给形参 x。函数内部修改的是形参 x，不会改变 main 里的 a。而且这里没有接收 f(a) 的返回值，所以 a 仍然是 5。

易错点：

C 语言函数参数默认是值传递。
函数里改形参，不会直接改外面的实参变量。

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
int f(void)
4
{
5
    static int a = 0;
6
    a++;
7
    return a;
8
}
9

10
int main(void)
11
{
12
    printf("%d ", f());
13
    printf("%d ", f());
14
    printf("%d\n", f());
15
    return 0;
16
}

答案：

1
1 2 3

解析：

static int a = 0; 只初始化一次，并且每次函数调用结束后，a 的值会保留下来。

三次调用过程：

1
第 1 次：a 从 0 变成 1，返回 1
2
第 2 次：a 从 1 变成 2，返回 2
3
第 3 次：a 从 2 变成 3，返回 3

易错点：

普通局部变量每次进入函数重新创建。
static 局部变量只初始化一次，值会保留。

写出下面程序的输出结果。

1
#include <stdio.h>
2

3
int a = 100;
4

5
void fun(void)
6
{
7
    int a = 10;
8
    printf("%d\n", a);
9
}
10

11
int main(void)
12
{
13
    fun();
14
    printf("%d\n", a);
15
    return 0;
16
}

答案：

解析：

全局变量：

1
int a = 100;

函数 fun 内部又定义了局部变量：

1
int a = 10;

在 fun 内部，局部变量 a 会临时“遮住”全局变量 a，所以 fun() 输出 10。回到 main 后，访问的是全局变量 a，所以输出 100。

易错点：

局部变量和全局变量同名时，局部变量优先。

手写程序题

写函数 max(int a, int b)，返回两个数中的较大值。

答案：

1
int max(int a, int b)
2
{
3
    if (a > b) {
4
        return a;
5
    }
6
    return b;
7
}

易错点：

函数有返回值时，记得写 return。

写函数 sum(int n)，返回 1 + 2 + ... + n。

答案：

1
int sum(int n)
2
{
3
    int i;
4
    int s = 0;
5

6
    for (i = 1; i <= n; i++) {
7
        s += i;
8
    }
9

10
    return s;
11
}

易错点：

求和初值是 0。
循环要包含 n，条件写 i <= n。

写函数 is_even(int n)，判断一个数是否为偶数。

答案：

1
int is_even(int n)
2
{
3
    return n % 2 == 0;
4
}

易错点：

表达式 n % 2 == 0 成立时值为 1，不成立时值为 0。

写函数求三个整数中的最大值。

答案：

1
int max3(int a, int b, int c)
2
{
3
    int max = a;
4

5
    if (b > max) {
6
        max = b;
7
    }
8
    if (c > max) {
9
        max = c;
10
    }
11

12
    return max;
13
}

易错点：

先假设第一个数最大，再逐个比较。

写函数判断一个年份是否为闰年。

答案：

1
int is_leap_year(int year)
2
{
3
    return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
4
}

易错点：

闰年规则里的 && 和 || 建议加括号。

写函数求两个整数的最大公约数。

答案：

1
int gcd(int a, int b)
2
{
3
    int t;
4

5
    while (b != 0)
6
    {
7
        t = a % b;
8
        a = b;
9
        b = t;
10
    }
11

12
    return a;
13
}

易错点：

辗转相除法循环结束时，a 是最大公约数。

写函数判断一个正整数是否为素数。

答案：

1
int is_prime(int n)
2
{
3
    int i;
4

5
    if (n <= 1) {
6
        return 0;
7
    }
8

9
    for (i = 2; i < n; i++) {
10
        if (n % i == 0) {
11
            return 0;
12
        }
13
    }
14

15
    return 1;
16
}

易错点：

1 不是素数。
发现一个因子就可以直接返回 0。

在主函数中调用上题函数，输出 1 到 100 之间所有素数。

答案：

1
#include <stdio.h>
2

3
int is_prime(int n)
4
{
5
    int i;
6

7
    if (n <= 1) {
8
        return 0;
9
    }
10

11
    for (i = 2; i < n; i++) {
12
        if (n % i == 0) {
13
            return 0;
14
        }
15
    }
16

17
    return 1;
18
}
19

20
int main(void)
21
{
22
    int i;
23

24
    for (i = 1; i <= 100; i++) {
25
        if (is_prime(i)) {
26
            printf("%d ", i);
27
        }
28
    }
29

30
    return 0;
31
}

易错点：

调用函数前要先定义函数，或者在前面写函数声明。

用递归函数求 n!。

答案：

1
long long fact(int n)
2
{
3
    if (n == 0 || n == 1) {
4
        return 1;
5
    }
6

7
    return n * fact(n - 1);
8
}

易错点：

递归必须有结束条件。
阶乘增长很快，建议用 long long。

用递归函数求斐波那契数列第 n 项。

答案：

1
int fib(int n)
2
{
3
    if (n == 1 || n == 2) {
4
        return 1;
5
    }
6

7
    return fib(n - 1) + fib(n - 2);
8
}

易错点：

这里按第 1 项和第 2 项都为 1 来写。
递归版本容易重复计算，适合初学理解，不适合很大的 n。

写函数求数组元素之和。

答案：

1
int array_sum(int a[], int n)
2
{
3
    int i;
4
    int sum = 0;
5

6
    for (i = 0; i < n; i++) {
7
        sum += a[i];
8
    }
9

10
    return sum;
11
}

易错点：

数组传参时，通常还要额外传数组长度 n。

写函数统计字符串长度。

答案：

1
int my_strlen(char s[])
2
{
3
    int len = 0;
4

5
    while (s[len] != '\0') {
6
        len++;
7
    }
8

9
    return len;
10
}

易错点：

字符串长度不包括结尾的 '\0'。

写函数将一个字符串中的小写字母转换为大写字母。

答案：

1
void to_upper(char s[])
2
{
3
    int i;
4

5
    for (i = 0; s[i] != '\0'; i++) {
6
        if (s[i] >= 'a' && s[i] <= 'z') {
7
            s[i] = s[i] - 'a' + 'A';
8
        }
9
    }
10
}

易错点：

这个函数直接修改传入的字符数组。
字符串常量不能传进来修改，应该传字符数组。

改错题

找出并改正下面程序中的错误。

1
#include <stdio.h>
2

3
int add(int x, int y)
4
{
5
    printf("%d\n", x + y);
6
}
7

8
int main(void)
9
{
10
    int c;
11
    c = add(2, 3);
12
    printf("%d\n", c);
13
    return 0;
14
}

答案：

原程序的核心问题是：add 被声明为返回 int，但函数内部没有 return，只是打印了结果。主函数里又写了：

1
c = add(2, 3);

这说明 add 应该返回两个数之和。

正确写法：

1
#include <stdio.h>
2

3
int add(int x, int y)
4
{
5
    return x + y;
6
}
7

8
int main(void)
9
{
10
    int c;
11

12
    c = add(2, 3);
13
    printf("%d\n", c);
14

15
    return 0;
16
}

易错点：

如果函数要把结果交给调用者，就用 return。
如果函数只是负责输出，可以写成 void，但主函数就不能再 c = add(...)。

修改下面递归函数，使其能正确计算阶乘。

1
int fact(int n)
2
{
3
    return n * fact(n - 1);
4
}

答案：

1
int fact(int n)
2
{
3
    if (n == 0 || n == 1) {
4
        return 1;
5
    }
6

7
    return n * fact(n - 1);
8
}

解析：

原函数没有递归出口，会一直调用下去：

1
fact(n) -> fact(n-1) -> fact(n-2) -> ...

所以必须加结束条件。

易错点：

递归函数必须有“什么时候停止”的条件。
0! 和 1! 都是 1。

14. 自测清单

我知道函数为什么能让程序更清晰。
我能自己写一个有参数、有返回值的函数。
我能区分形参和实参。
我知道什么是局部变量，什么是全局变量。
我能解释值传递为什么不会直接改变外部变量。
我会写最简单的递归函数。

15. 学习建议

第 6 章一定要多写，不要只读。
每写一个函数，先用一句中文说明“它输入什么，输出什么”。
如果一个函数太长，就想一想能不能再拆小一点。
递归题先不要贪多，先把阶乘和斐波那契吃透。

第 6 章 函数

对应教材目录

本章目标

1. 为什么要学函数

2. 函数的基本形式

3. 函数的定义和调用

4. 无参和有参

4.1 无参函数

4.2 有参函数

5. 有返回值和无返回值

5.1 有返回值

5.2 无返回值

6. 参数传递

7. 函数声明

8. 局部变量和全局变量

8.1 局部变量

8.2 全局变量

9. static 局部变量

10. 递归的入门理解

11. 本章常见模板

11.1 求最大值函数

11.2 判断奇偶函数

11.3 数组求和函数

12. 本章最容易错的点

13. 手写题

写结果题

手写程序题

改错题

14. 自测清单

15. 学习建议

第 6 章函数