C语言函数

概述

本文档详细介绍C语言中函数的使用方法，包括函数的定义、声明、调用、参数传递、返回值、递归函数、静态函数等内容。函数是C语言中组织代码的基本单位，合理使用函数可以提高代码的可读性、可维护性和复用性。

函数的基本概念

函数是一段完成特定任务的代码块，它可以接收输入参数，执行特定操作，并返回结果（或不返回结果）。在C语言中，函数的使用包括以下几个步骤：

  1. 函数声明：告诉编译器函数的名称、参数类型和返回类型
  2. 函数定义：实现函数的具体功能
  3. 函数调用：在程序中使用函数

函数的声明与定义

函数声明

函数声明（也称为函数原型）的基本语法如下：

1
返回类型 函数名(参数类型1 参数名1, 参数类型2 参数名2, ...);

函数定义

函数定义的基本语法如下：

1
2
3
4
返回类型 函数名(参数类型1 参数名1, 参数类型2 参数名2, ...) {
    // 函数体：实现具体功能的代码
    return 返回值; // 如果返回类型不是void，则需要返回值
}

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 函数原型声明
void print_hello();                            // 无参数无返回值的函数
void print_number(int num);                   // 带参数无返回值的函数
int add(int a, int b);                        // 带参数带返回值的函数

// 函数定义
void print_hello() {
    printf("Hello from function!\n");
}

void print_number(int num) {
    printf("你传入的数字是: %d\n", num);
}

int add(int a, int b) {
    return a + b;
}

函数的调用

函数调用的基本语法

1
函数名(参数1, 参数2, ...);

如果函数有返回值，可以将其赋值给变量：

1
返回类型 变量名 = 函数名(参数1, 参数2, ...);

示例代码

1
2
3
4
5
6
7
8
9
// 调用无参数无返回值的函数
print_hello();

// 调用带参数无返回值的函数
print_number(123);

// 调用带参数带返回值的函数
int result = add(10, 20);
printf("10 + 20 = %d\n", result);

参数传递方式

C语言中函数参数的传递方式有两种：值传递和指针传递。

值传递

值传递是指将实参的值复制一份传递给形参，函数内部对形参的修改不会影响实参的值。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 值传递示例
void swap_by_value(int x, int y) {
    int temp = x;
    x = y;
    y = temp;
    // 这里交换的只是形参的值，实参不会改变
    printf("函数内部交换后: x = %d, y = %d\n", x, y);
}

// 调用值传递函数
int x = 10, y = 20;
printf("交换前: x = %d, y = %d\n", x, y);
swap_by_value(x, y);
printf("值传递交换后: x = %d, y = %d\n", x, y); // 实参值不变

指针传递

指针传递是指将实参的地址传递给形参，函数内部通过指针可以修改实参的值。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
// 指针传递示例
void swap_by_reference(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
    // 这里通过指针修改了实参的值
}

// 调用指针传递函数
int x = 10, y = 20;
printf("交换前: x = %d, y = %d\n", x, y);
swap_by_reference(&x, &y);
printf("指针传递交换后: x = %d, y = %d\n", x, y); // 实参值被修改

数组作为参数

数组作为参数传递时，实际上传递的是数组首元素的地址，因此函数内部对数组元素的修改会影响原数组。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 数组作为参数示例
void modify_array(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2; // 修改数组元素
    }
}

// 调用修改数组的函数
int numbers[] = {1, 2, 3, 4, 5};
int size = sizeof(numbers) / sizeof(numbers[0]);

printf("修改前的数组: ");
for (int i = 0; i < size; i++) {
    printf("%d ", numbers[i]);
}
printf("\n");

modify_array(numbers, size);

printf("修改后的数组: ");
for (int i = 0; i < size; i++) {
    printf("%d ", numbers[i]);
}
printf("\n");

递归函数

递归函数是指在函数内部调用自身的函数。递归函数通常用于解决可以分解为相同问题的子问题的情况，如阶乘计算、斐波那契数列等。

递归函数的基本结构

1
2
3
4
5
6
7
返回类型 函数名(参数) {
    if (基本情况) {
        return 基本情况的值;
    } else {
        return 递归调用 + 其他操作;
    }
}

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
// 计算阶乘的递归函数
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;  // 递归终止条件
    } else {
        return n * factorial(n - 1);  // 递归调用
    }
}

// 调用递归函数
int n = 5;
printf("%d的阶乘是: %d\n", n, factorial(n));

补充示例：斐波那契数列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 计算斐波那契数列的递归函数
int fibonacci(int n) {
    if (n <= 1) {
        return n;  // 递归终止条件
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);  // 递归调用
    }
}

// 调用递归函数
printf("斐波那契数列的前10项: ");
for (int i = 0; i < 10; i++) {
    printf("%d ", fibonacci(i));
}
printf("\n");

递归的优缺点

优点

  • 代码简洁，逻辑清晰
  • 适合解决分治问题

缺点

  • 可能导致栈溢出（递归深度过大）
  • 可能存在重复计算（如斐波那契数列）
  • 效率通常低于迭代方法

静态函数

静态函数是指使用static关键字修饰的函数，它只能在当前文件中被访问，不能被其他文件调用。

示例代码

1
2
3
4
5
6
7
8
9
10
// 静态函数示例
static void static_function() {
    static int count = 0;  // 静态变量，只会初始化一次
    count++;
    printf("静态函数被调用了 %d 次\n", count);
}

// 调用静态函数
static_function();
static_function();  // 静态函数的局部变量会保持上次调用的值

静态变量

在函数内部使用static关键字修饰的变量称为静态局部变量，它的特点是：

  • 只会初始化一次
  • 函数调用结束后不会被销毁
  • 下次调用函数时会保留上次的值

内联函数

内联函数是指使用inline关键字修饰的函数，编译器会尝试将内联函数的代码直接嵌入到调用处，而不是通过函数调用的方式执行，从而提高程序的执行效率。

示例代码

1
2
3
4
5
6
7
8
// 内联函数示例
inline int max(int a, int b) {
    return (a > b) ? a : b;
}

// 调用内联函数
printf("max(15, 25) = %d\n", max(15, 25));
printf("max(-5, 0) = %d\n", max(-5, 0));

注意事项

  • 内联函数适用于代码简短、调用频繁的函数
  • 内联函数的定义通常放在头文件中
  • 编译器可能会忽略inline关键字的请求（例如对于复杂的函数）

函数的作用域和生命周期

作用域

  • 函数作用域：函数中定义的变量只在函数内部可见
  • 文件作用域：在函数外部定义的变量和函数在整个文件中可见
  • 全局作用域：在所有函数外部定义的变量和非静态函数在整个程序中可见

生命周期

  • 自动变量：函数内部定义的普通变量，生命周期从函数调用开始到函数返回结束
  • 静态变量：使用static修饰的变量，生命周期从程序开始到程序结束
  • 全局变量：在函数外部定义的变量，生命周期从程序开始到程序结束

函数的高级特性

函数指针

函数指针是指向函数的指针变量，它可以存储函数的地址，并通过指针调用函数。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 函数定义
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

// 函数指针的使用
int (*operation)(int, int);  // 声明函数指针

operation = add;  // 指向add函数
printf("10 + 5 = %d\n", operation(10, 5));

operation = subtract;  // 指向subtract函数
printf("10 - 5 = %d\n", operation(10, 5));

回调函数

回调函数是指作为参数传递给另一个函数的函数，它通常在特定事件发生时被调用。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 回调函数类型定义
typedef void (*Callback)(int);

// 回调函数实现
void print_result(int result) {
    printf("计算结果: %d\n", result);
}

// 接受回调函数的函数
void calculate(int a, int b, Callback callback) {
    int result = a + b;
    callback(result);  // 调用回调函数
}

// 使用回调函数
calculate(10, 20, print_result);

可变参数函数

可变参数函数是指参数数量可变的函数，例如printf函数。在C语言中，可以使用<stdarg.h>头文件中的工具来实现可变参数函数。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdarg.h>

// 计算可变参数的和
int sum(int count, ...) {
    va_list args;  // 定义参数列表
    int total = 0;
    
    va_start(args, count);  // 初始化参数列表
    
    for (int i = 0; i < count; i++) {
        total += va_arg(args, int);  // 获取下一个参数
    }
    
    va_end(args);  // 清理参数列表
    
    return total;
}

// 调用可变参数函数
printf("1 + 2 + 3 = %d\n", sum(3, 1, 2, 3));
printf("4 + 5 + 6 + 7 = %d\n", sum(4, 4, 5, 6, 7));

函数重载模拟

C语言本身不支持函数重载（即同名函数但参数列表不同），但可以通过宏和函数指针来模拟函数重载的效果。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 使用宏模拟函数重载
#include <stdio.h>

// 不同类型的函数实现
void print_int(int value) {
    printf("整数: %d\n", value);
}

void print_float(float value) {
    printf("浮点数: %f\n", value);
}

void print_string(const char* value) {
    printf("字符串: %s\n", value);
}

// 使用宏模拟重载
#define print(value) _Generic((value), \
    int: print_int, \
    float: print_float, \
    char*: print_string \
)(value)

// 使用模拟的重载函数
print(10);          // 调用print_int
print(3.14f);       // 调用print_float
print("Hello");     // 调用print_string

综合示例

示例1：计算器函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 计算器函数
float calculate(char operator, float a, float b) {
    switch (operator) {
        case '+':
            return a + b;
        case '-':
            return a - b;
        case '*':
            return a * b;
        case '/':
            if (b != 0) {
                return a / b;
            } else {
                printf("错误：除数不能为零\n");
                return 0;
            }
        default:
            printf("错误：无效的运算符\n");
            return 0;
    }
}

// 使用计算器函数
printf("5 + 3 = %.2f\n", calculate('+', 5, 3));
printf("5 - 3 = %.2f\n", calculate('-', 5, 3));
printf("5 * 3 = %.2f\n", calculate('*', 5, 3));
printf("5 / 3 = %.2f\n", calculate('/', 5, 3));

示例2：排序函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 冒泡排序函数
void bubble_sort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 使用排序函数
int numbers[] = {5, 2, 9, 1, 5, 6};
int size = sizeof(numbers) / sizeof(numbers[0]);

printf("排序前: ");
for (int i = 0; i < size; i++) {
    printf("%d ", numbers[i]);
}
printf("\n");

bubble_sort(numbers, size);

printf("排序后: ");
for (int i = 0; i < size; i++) {
    printf("%d ", numbers[i]);
}
printf("\n");

示例3：二分查找函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 二分查找函数（要求数组已排序）
int binary_search(int arr[], int size, int target) {
    int left = 0;
    int right = size - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (arr[mid] == target) {
            return mid;  // 找到目标元素，返回索引
        } else if (arr[mid] < target) {
            left = mid + 1;  // 目标在右半部分
        } else {
            right = mid - 1;  // 目标在左半部分
        }
    }
    
    return -1;  // 未找到目标元素
}

// 使用二分查找函数
int sorted_numbers[] = {1, 2, 5, 5, 6, 9};
int size = sizeof(sorted_numbers) / sizeof(sorted_numbers[0]);
int target = 5;

int index = binary_search(sorted_numbers, size, target);
if (index != -1) {
    printf("元素 %d 在数组中的索引位置: %d\n", target, index);
} else {
    printf("元素 %d 不在数组中\n", target);
}

函数设计最佳实践

  1. 函数应该有单一职责：每个函数应该只做一件事情，并且做好它
  2. 函数名应该清晰表达函数的功能：使用有意义的函数名，避免使用模糊的名称
  3. 函数参数应该合理：参数数量不宜过多，通常不超过5个
  4. 函数应该有适当的注释：使用注释说明函数的功能、参数和返回值
  5. 避免函数过长：通常函数长度不应超过50-100行
  6. 合理使用返回值：函数应该返回有意义的值，便于调用者判断函数执行结果
  7. 避免全局变量：尽量使用参数传递和返回值，而不是依赖全局变量
  8. 注意参数的有效性检查：对传入的参数进行合理性检查，避免程序崩溃
  9. 合理使用递归：对于适合递归的问题使用递归，对于不适合的问题使用迭代
  10. 考虑函数的可测试性：设计函数时考虑如何方便地进行单元测试

总结

C语言中的函数是组织代码的基本单位，通过本文档的学习，我们了解了：

  1. 函数的基本概念：函数的声明、定义和调用
  2. 参数传递方式：值传递和指针传递的区别
  3. 递归函数：递归的基本原理和应用场景
  4. 静态函数：静态函数的特点和使用方法
  5. 内联函数：内联函数的作用和使用场景
  6. 函数的高级特性：函数指针、回调函数和可变参数函数
  7. 函数重载模拟：使用宏模拟函数重载的效果
  8. 函数设计最佳实践：如何设计好的函数

合理使用函数可以使代码更加模块化、可读性更高、更容易维护和扩展。在实际编程中，我们应该根据具体需求选择合适的函数设计方案，以达到最佳的代码质量和执行效率。

functions.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
#include <stdio.h>
#include <math.h>

/**
 * @brief 函数示例程序
 * @details 这个程序演示了C语言中函数的各种用法，包括函数定义、
 *          函数调用、参数传递、返回值、递归函数等。
 * @return 0 表示程序成功执行
 */

// =========================
// 函数原型声明
// =========================
void print_hello();                            // 无参数无返回值的函数
void print_number(int num);                   // 带参数无返回值的函数
int add(int a, int b);                        // 带参数带返回值的函数
int factorial(int n);                         // 递归函数
void swap_by_value(int x, int y);             // 值传递示例
void swap_by_reference(int *x, int *y);       // 指针传递示例
static void static_function();                // 静态函数
int max(int a, int b);                 // 普通函数

/**
 * @brief 主函数
 * @return 0 表示程序成功执行
 */
int main() {
    // =========================
    // 调用无参数无返回值的函数
    // =========================
    printf("=== 调用无参数无返回值的函数 ===\n");
    print_hello();
    
    printf("\n");
    
    // =========================
    // 调用带参数无返回值的函数
    // =========================
    printf("=== 调用带参数无返回值的函数 ===\n");
    print_number(123);
    
    printf("\n");
    
    // =========================
    // 调用带参数带返回值的函数
    // =========================
    printf("=== 调用带参数带返回值的函数 ===\n");
    int result = add(10, 20);
    printf("10 + 20 = %d\n", result);
    
    printf("\n");
    
    // =========================
    // 调用递归函数
    // =========================
    printf("=== 调用递归函数 ===\n");
    int n = 5;
    printf("%d的阶乘是: %d\n", n, factorial(n));
    
    printf("\n");
    
    // =========================
    // 值传递与指针传递比较
    // =========================
    printf("=== 值传递与指针传递比较 ===\n");
    
    int x = 10, y = 20;
    printf("交换前: x = %d, y = %d\n", x, y);
    
    // 值传递 - 不会改变实参的值
    swap_by_value(x, y);
    printf("值传递交换后: x = %d, y = %d\n", x, y);
    
    // 指针传递 - 会改变实参的值
    swap_by_reference(&x, &y);
    printf("指针传递交换后: x = %d, y = %d\n", x, y);
    
    printf("\n");
    
    // =========================
    // 调用内联函数
    // =========================
    printf("=== 调用内联函数 ===\n");
    printf("max(15, 25) = %d\n", max(15, 25));
    printf("max(-5, 0) = %d\n", max(-5, 0));
    
    printf("\n");
    
    // =========================
    // 调用静态函数
    // =========================
    printf("=== 调用静态函数 ===\n");
    static_function();
    static_function();  // 静态函数的局部变量会保持上次调用的值
    
    return 0;
}

// =========================
// 函数定义
// =========================

/**
 * @brief 打印"Hello from function!"
 * @details 无参数无返回值的函数示例
 */
void print_hello() {
    printf("Hello from function!\n");
}

/**
 * @brief 打印一个整数
 * @details 带参数无返回值的函数示例
 * @param num 要打印的整数
 */
void print_number(int num) {
    printf("你传入的数字是: %d\n", num);
}

/**
 * @brief 计算两个整数的和
 * @details 带参数带返回值的函数示例
 * @param a 第一个整数
 * @param b 第二个整数
 * @return 两个整数的和
 */
int add(int a, int b) {
    return a + b;
}

/**
 * @brief 计算阶乘
 * @details 递归函数示例
 * @param n 要计算阶乘的整数
 * @return n的阶乘
 */
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;  // 递归终止条件
    } else {
        return n * factorial(n - 1);  // 递归调用
    }
}

/**
 * @brief 交换两个整数的值（值传递）
 * @details 演示值传递的特点：不会改变实参的值
 * @param x 第一个整数
 * @param y 第二个整数
 */
void swap_by_value(int x, int y) {
    int temp = x;
    x = y;
    y = temp;
    // 这里交换的只是形参的值，实参不会改变
    printf("函数内部交换后: x = %d, y = %d\n", x, y);
}

/**
 * @brief 交换两个整数的值（指针传递）
 * @details 演示指针传递的特点：会改变实参的值
 * @param x 指向第一个整数的指针
 * @param y 指向第二个整数的指针
 */
void swap_by_reference(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
    // 这里通过指针修改了实参的值
}

/**
 * @brief 静态函数示例
 * @details 静态函数只能在当前文件中访问
 *          静态函数内部的静态变量会保持上次调用的值
 */
static void static_function() {
    static int count = 0;  // 静态变量，只会初始化一次
    count++;
    printf("静态函数被调用了 %d 次\n", count);
}

/**
 * @brief 求两个整数的最大值
 * @details 内联函数示例，适合简单的函数，编译器会将其展开
 * @param a 第一个整数
 * @param b 第二个整数
 * @return 两个整数中的最大值
 */
int max(int a, int b) {
    return (a > b) ? a : b;
}