C语言函数详解：从基础概念到高级应用
函数是C语言编程的核心概念之一，它允许我们将代码组织成可重用的模块。理解函数的工作原理对于编写高效、可维护的C程序至关重要。
一、函数基本概念
什么是函数？
函数是一段可以重复执行的代码块，它可以接受不同的参数，完成对应的操作，并可能返回一个结果。
函数声明示例：
1
2
3
| int plus_one(int n) {
return n + 1;
}
|
函数声明的四个关键要素：
- 返回值类型：函数声明时首先需要给出返回值的类型，上例是
int，表示函数返回一个整数
- 参数列表：函数名后面的圆括号里面声明参数的类型和参数名
- 函数体：函数体写在大括号里面，包含具体的执行代码
- return语句：给出函数的返回值，程序运行到这一行会结束函数调用
函数调用示例：
参数个数必须匹配：
1
2
3
4
5
6
7
8
9
10
| int plus_one(int n) {
return n + 1;
}
plus_one(5);
plus_one(2, 2);
plus_one();
|
函数必须先声明后使用：
1
2
3
4
5
6
|
int a = plus_one(13);
int plus_one(int n) {
return n + 1;
}
|
void函数示例：
1
2
3
4
| void myFunc(void) {
printf("这是一个void函数\n");
}
|
递归函数示例（斐波那契数列）：
1
2
3
4
5
6
| unsigned long Fibonacci(unsigned n) {
if (n > 2)
return Fibonacci(n - 1) + Fibonacci(n - 2);
else
return 1;
}
|
二、main()函数
main()函数是C程序的入口点，所有的程序必须包含一个main()函数。
标准main()函数写法：
1
2
3
4
5
6
| #include <stdio.h>
int main(void) {
printf("Hello World\n");
return 0;
}
|
返回值约定：
return 0：表示程序运行成功- 非零返回值：表示程序运行失败或出现问题
省略return的main()函数：
1
2
3
4
| int main(void) {
printf("Hello World\n");
}
|
带参数的main()函数：
1
2
3
4
5
6
7
| int main(int argc, char* argv[]) {
printf("参数个数: %d\n", argc);
for (int i = 0; i < argc; i++) {
printf("参数 %d: %s\n", i, argv[i]);
}
return 0;
}
|
三、参数的传值引用
C语言中，函数参数传递默认是传值引用，即传入的是变量值的拷贝。
传值引用的特点：
1
2
3
4
5
6
7
8
9
10
| void increment(int a) {
a++;
}
int main() {
int i = 10;
increment(i);
printf("%d\n", i);
return 0;
}
|
通过返回值修改变量：
1
2
3
4
5
6
7
8
9
10
11
| int increment(int a) {
a++;
return a;
}
int main() {
int i = 10;
i = increment(i);
printf("%d\n", i);
return 0;
}
|
交换变量的错误实现：
1
2
3
4
5
6
7
8
9
10
11
12
13
| void Swap(int x, int y) {
int temp;
temp = x;
x = y;
y = temp;
}
int main() {
int a = 1, b = 2;
Swap(a, b);
printf("a=%d, b=%d\n", a, b);
return 0;
}
|
通过指针实现变量交换：
1
2
3
4
5
6
7
8
9
10
11
12
13
| void Swap(int* x, int* y) {
int temp;
temp = *x;
*x = *y;
*y = temp;
}
int main() {
int a = 1, b = 2;
Swap(&a, &b);
printf("a=%d, b=%d\n", a, b);
return 0;
}
|
不要返回局部变量的指针：
1
2
3
4
5
|
int* f(void) {
int i = 10;
return &i;
}
|
四、函数指针
函数指针是指向函数的指针变量，可以动态调用不同的函数。
函数指针声明：
1
2
3
4
5
6
7
8
9
10
11
12
13
| void print(int a) {
printf("%d\n", a);
}
int main() {
void (*print_ptr)(int) = &print;
(*print_ptr)(10);
return 0;
}
|
函数名的本质：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| void print(int a) {
printf("%d\n", a);
}
int main() {
if (print == &print) {
printf("函数名本身就是指针\n");
}
print(10);
(*print)(10);
(&print)(10);
return 0;
}
|
函数指针作为参数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| #include <stdio.h>
int add(int a, int b) {
return a + b;
}
int subtract(int a, int b) {
return a - b;
}
int compute(int (*func)(int, int), int x, int y) {
return func(x, y);
}
int main() {
int result1 = compute(add, 5, 3);
int result2 = compute(subtract, 5, 3);
printf("加法结果: %d\n", result1);
printf("减法结果: %d\n", result2);
return 0;
}
|
五、函数原型
函数原型允许函数先使用后声明，提高代码的可读性。
函数原型的使用：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| #include <stdio.h>
int twice(int num);
int main() {
int result = twice(5);
printf("结果: %d\n", result);
return 0;
}
int twice(int num) {
return 2 * num;
}
|
函数原型的写法：
1
2
3
4
5
|
int twice(int);
int twice(int num);
|
六、exit()函数
exit()函数用于立即终止整个程序的运行。
exit()函数的使用：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| #include <stdio.h>
#include <stdlib.h>
int main() {
printf("程序开始运行\n");
exit(EXIT_SUCCESS);
printf("这行不会执行\n");
return 0;
}
|
atexit()函数：注册退出处理函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| #include <stdio.h>
#include <stdlib.h>
void cleanup(void) {
printf("执行清理工作...\n");
}
int main() {
atexit(cleanup);
printf("程序运行中...\n");
exit(EXIT_FAILURE);
return 0;
}
|
七、函数说明符
1. extern说明符
1
2
3
4
5
6
7
|
extern int external_function(int arg);
int main() {
int result = external_function(10);
return 0;
}
|
2. static说明符
static局部变量：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| #include <stdio.h>
void counter(void) {
static int count = 1;
printf("计数: %d\n", count);
count++;
}
int main() {
counter();
counter();
counter();
counter();
return 0;
}
|
static函数：
1
2
3
4
|
static int internal_function(int num) {
return num * 2;
}
|
3. const说明符
保护指针指向的值：
1
2
3
4
| void print_string(const char* str) {
printf("%s\n", str);
}
|
保护指针本身：
1
2
3
4
| void process_data(int* const ptr) {
*ptr = 100;
}
|
同时保护指针和指向的值：
1
2
3
4
5
| void read_only(const int* const ptr) {
printf("值: %d\n", *ptr);
}
|
八、可变参数
可变参数函数可以接受不定数量的参数。
可变参数函数声明：
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
| #include <stdio.h>
#include <stdarg.h>
double average(int count, ...) {
double total = 0;
va_list ap;
va_start(ap, count);
for (int i = 0; i < count; i++) {
total += va_arg(ap, double);
}
va_end(ap);
return total / count;
}
int main() {
double avg1 = average(3, 1.0, 2.0, 3.0);
double avg2 = average(5, 10.0, 20.0, 30.0, 40.0, 50.0);
printf("平均值1: %.2f\n", avg1);
printf("平均值2: %.2f\n", avg2);
return 0;
}
|
printf风格的格式化函数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| #include <stdio.h>
#include <stdarg.h>
void my_printf(const char* format, ...) {
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
}
int main() {
my_printf("整数: %d, 浮点数: %.2f, 字符串: %s\n",
100, 3.14159, "Hello");
return 0;
}
|
九、函数最佳实践
- 单一职责原则：每个函数只完成一个明确的任务
- 合理的函数长度：函数不宜过长，建议不超过50行
- 有意义的函数名：函数名应该清晰表达其功能
- 适当的参数数量：避免参数过多，考虑使用结构体
- 错误处理：对可能的错误情况进行处理
- 文档注释：为函数添加清晰的注释说明
示例：良好的函数设计
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
| #include <stdio.h>
#include <stdbool.h>
bool is_prime(int number) {
if (number < 2) return false;
if (number == 2) return true;
if (number % 2 == 0) return false;
for (int i = 3; i * i <= number; i += 2) {
if (number % i == 0) return false;
}
return true;
}
void print_primes_in_range(int start, int end) {
printf("在%d到%d之间的质数:\n", start, end);
for (int i = start; i <= end; i++) {
if (is_prime(i)) {
printf("%d ", i);
}
}
printf("\n");
}
int main() {
print_primes_in_range(1, 50);
return 0;
}
|
总结
函数是C语言编程的基石，掌握函数的使用对于编写高质量的C程序至关重要。从基本的函数声明和调用，到高级的函数指针和可变参数，理解这些概念将大大提升你的编程能力。记住良好的函数设计原则，编写出清晰、可维护的代码。