学会使用C语言中的函数和函数调用

# 1. C语言函数基础

## 1.1 什么是函数？

在C语言中，函数是一段封装了一定功能的代码块，可以被多次调用和执行。函数由函数头部、函数返回类型、函数名称、参数列表、函数体组成。

#include <stdio.h>

// 函数声明
int max(int num1, int num2);

int main() {
    int a = 100;
    int b = 200;
    int ret;

    // 调用函数
    ret = max(a, b);

    printf( "Max value is : %d\n", ret );
    return 0;
}

// 函数定义
int max(int num1, int num2) {
    return (num1 > num2 ) ? num1 : num2;
}

**代码解析：**
- 首先在代码中声明了一个`max`函数, 然后在`main`函数中调用`max`函数，传递参数`a`和`b`给`max`函数，`max`函数比较这两个参数并返回最大值

## 1.2 函数的优势与用途

函数的优势在于提高代码的模块化和可重用性，减少重复代码，便于维护和管理。常见的函数包括数学计算、字符串操作、文件操作等。

## 1.3 函数的声明与定义

函数的声明需要提供函数名、参数列表和返回类型，并不需要函数体，而函数的定义包括函数名、参数列表、返回类型和函数体。

#include <stdio.h>

// 函数声明
int max(int num1, int num2);

int main() {
    // function call
    int result = max(10, 20);
    printf("Max value is : %d\n", result);
    return 0;
}

// 函数定义
int max(int num1, int num2) {
    return (num1 > num2) ? num1 : num2;
}

**代码总结：**
- 通过函数声明和函数定义，可以实现函数的先调用后定义，提供了更好的代码结构和可读性。

# 2. C语言函数的参数传递

在C语言中，函数的参数传递是一个非常重要的概念。参数的传递方式可以影响函数的行为和效率。在本章中，我们将深入探讨C语言函数的参数传递方式，包括值传递与引用传递、函数参数的默认值以及函数参数的可变数量。

### 2.1 值传递与引用传递

#### 场景模拟：
我们先来看一个简单的示例，演示值传递和引用传递的区别：

def change_value(x):
    x = 2

a = 1
change_value(a)
print(a)  # 输出结果是多少？

#### 代码解释与总结：
- 在值传递中，函数内部对参数的更改并不会影响到原始值。
- 在引用传递中，函数内部对参数的更改会影响到原始值。
- Python中没有严格意义上的引用传递，但通过一些技巧可以模拟引用传递的效果。

#### 结果说明：
在上述示例中，输出结果为1，因为传递给`change_value`函数的是`a`的值，而函数内部对`x`的修改不会影响到`a`的值。

### 2.2 函数参数的默认值

#### 场景模拟：
在某些情况下，我们希望函数的参数具有默认值，当不传递参数时可以采用默认值。下面是一个示例：

public void greet(String name, String greeting="Hello") {
    System.out.println(greeting + ", " + name + "!");
}

greet("Alice");  // 输出结果是什么？
greet("Bob", "Hi");  // 输出结果又是什么？

#### 代码解释与总结：
- 函数参数的默认值在定义函数时指定，调用时可以根据需要传递或使用默认值。
- 默认值通常用于简化函数调用，避免过多参数的传递。

#### 结果说明：
在上述示例中，第一次调用`greet`函数时，输出结果为`Hello, Alice!`，而第二次调用时，输出结果为`Hi, Bob!`，因为第一个调用使用了默认值，而第二个调用覆盖了默认值。

### 2.3 函数参数的可变数量

#### 场景模拟：
有时候需要处理可变数量的参数，在Java中可以使用`...`符号表示可变长度参数。下面是一个示例：

public void sum(int... nums) {
    int total = 0;
    for (int num : nums) {
        total += num;
    }
    System.out.println("Sum: " + total);
}

sum(1, 2, 3);  // 输出结果是多少？
sum(4, 5, 6, 7);  // 输出结果又是多少？

#### 代码解释与总结：
- 可变数量参数允许函数接受不定数量的参数。
- 可变数量参数在函数内部被视为数组，可以通过循环等方式处理。

#### 结果说明：
在上述示例中，第一个调用`sum`函数时，输出结果为`Sum: 6`，第二个调用时，输出结果为`Sum: 22`，这是因为函数内部对传入的参数进行了求和操作。

# 3. C语言函数的返回值

在C语言中，函数可以有返回值，通过返回值可以将函数计算的结果传递给调用者。本章将介绍如何声明和定义函数的返回值，以及不同类型的返回值的用法。

#### 3.1 如何声明和定义函数的返回值

在C语言中，我们使用函数的返回类型来声明函数的返回值类型。例如，如果函数返回一个整数，我们可以这样声明：

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

上面的例子中，`int`是返回类型，表示该函数将返回一个整数值。

#### 3.2 返回单个值与返回多个值

C语言中的函数可以返回单个值，也可以返回多个值。例如，我们可以使用结构体来实现返回多个值的效果：

struct Point {
    int x;
    int y;
};

struct Point getCoordinates() {
    struct Point p;
    p.x = 3;
    p.y = 4;
    return p;
}

#### 3.3 返回指针与引用

除了返回具体数值或结构体外，C语言还支持返回指针或引用。例如，我们可以返回指向数组首元素的指针：

int* createArray(int size) {
    int* arr = (int*)malloc(size * sizeof(int));
    // 初始化数组
    return arr;
}

上面的例子中，函数`createArray`返回一个指向动态分配数组的指针。

通过本章的学习，读者将了解如何声明和定义函数的返回值，以及返回单个值、多个值、指针或引用的用法。这对于理解函数的数据传递和结果返回非常重要。

# 4. C语言函数调用

在C语言中，函数的调用是程序执行的重要部分之一。本章将深入探讨函数的调用方式、递归函数与非递归函数以及函数调用的栈原理。

#### 4.1 函数的调用方式

C语言中函数的调用可以通过以下方式进行：

#include <stdio.h>

// 函数声明
void greet();

int main() {
    // 调用函数
    greet();

    return 0;
}

// 函数定义
void greet() {
    printf("Hello, World!\n");
}

代码解释：
- 首先在主函数`main`中调用了函数`greet`，`greet`函数用于输出"Hello, World!"。
- 在主函数中调用函数时，直接使用函数名加上括号即可调用函数。
- 函数定义在函数声明之后，函数被调用时，程序的控制权会转移到被调用的函数中执行相应的代码。

#### 4.2 递归函数与非递归函数

在C语言中，函数可以是递归函数或非递归函数。

- **递归函数**：指在函数内部调用自身的函数。递归函数可以解决一些问题，如斐波那契数列等，但需要小心避免无限递归导致栈溢出。

#include <stdio.h>

// 递归函数计算阶乘
int factorial(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int num = 5;
    printf("Factorial of %d is %d\n", num, factorial(num));

    return 0;
}

- **非递归函数**：指函数内部没有调用自身的函数。非递归函数通常效率更高，不会有递归带来的额外开销。

#include <stdio.h>

// 非递归函数计算阶乘
int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

int main() {
    int num = 5;
    printf("Factorial of %d is %d\n", num, factorial(num));

    return 0;
}

#### 4.3 函数调用的栈原理

在C语言中，函数的调用过程是通过栈来实现的。每次函数调用时，当前函数的局部变量、参数以及函数返回地址都会被压入栈中，待函数执行完毕后从栈中弹出相关信息。

函数调用栈是后进先出的数据结构，确保函数执行的顺序符合程序设计的逻辑。

以上是关于C语言函数调用的基本内容，深入理解函数调用原理对于学习和编写高效的C程序至关重要。

# 5. C语言函数的作用域和生命周期

在C语言中，函数内部变量的作用域和生命周期是非常重要的概念。理解这些概念有助于编写更加健壮和可维护的代码。

## 5.1 函数内变量的作用域

在C语言中，函数内部定义的变量拥有自己的作用域，即它们只能在定义它们的函数内部被访问。这样做的好处是，可以避免变量名冲突和提高代码的可读性。

#include <stdio.h>

void myFunction() {
    int localVar = 10; // 局部变量，作用域仅限于myFunction函数
    printf("局部变量 localVar 的值：%d\n", localVar);
}

int main() {
    // printf("%d\n", localVar); // 无法访问局部变量 localVar，会导致编译错误
    myFunction();
    return 0;
}

**代码总结：** 函数内部定义的变量只能在该函数内部被访问，超出该函数范围将无法访问。

**结果说明：** 输出局部变量 localVar 的值为 10。

## 5.2 静态变量和全局变量

除了局部变量，C语言还支持静态变量和全局变量。静态变量在函数内部使用关键字`static`定义，全局变量则在所有函数外部定义。

#include <stdio.h>

int globalVar = 5; // 全局变量

void myFunction() {
    static int staticVar = 20; // 静态变量，函数调用完毕也不会销毁
    globalVar++;
    staticVar++;
    printf("全局变量 globalVar 的值：%d\n", globalVar);
    printf("静态变量 staticVar 的值：%d\n", staticVar);
}

int main() {
    myFunction();
    myFunction();
    return 0;
}

**代码总结：** 全局变量可以被所有函数访问，静态变量在函数调用完毕后仍然保留其值。

**结果说明：** 每次调用 myFunction 函数时，全局变量 globalVar 的值递增，而静态变量 staticVar 的值也递增，但保留了上一次调用的值。

## 5.3 变量的初始化和销毁

在C语言中，变量可以手动初始化，在不再需要时也可以手动销毁。

#include <stdio.h>

int main() {
    int *dynamicVar = NULL; // 动态变量

    dynamicVar = (int*)malloc(sizeof(int));
    *dynamicVar = 15;

    printf("动态变量 dynamicVar 的值：%d\n", *dynamicVar);

    free(dynamicVar); // 释放动态变量占用的内存

    return 0;
}

**代码总结：** 动态变量需要手动分配内存，并在使用完毕后释放内存，避免内存泄漏。

**结果说明：** 输出动态变量 dynamicVar 的值为 15，并成功释放占用的内存。

通过本章内容，读者将对C语言中函数内变量的作用域和生命周期有一个清晰的认识，从而编写更加高效和安全的代码。

# 6. C语言函数指针和回调函数

在C语言中，函数指针和回调函数是非常有用的概念，可以用于实现灵活的程序设计和解耦。本章将详细介绍函数指针的定义和用法，以及如何利用回调函数实现某些特定功能。

### 6.1 函数指针的定义和用法

函数指针是指向函数的指针变量，它可以存储函数的地址，从而使得可以动态地调用不同的函数。在C语言中，定义一个函数指针的语法如下：

#include <stdio.h>

// 定义一个函数指针类型
typedef void (*funcPtr)(int, int);

// 定义一个函数，用于接受函数指针作为参数
void performOperation(int x, int y, funcPtr operation) {
    operation(x, y);
}

// 定义两个简单的操作函数
void add(int x, int y) {
    printf("%d + %d = %d\n", x, y, x + y);
}

void subtract(int x, int y) {
    printf("%d - %d = %d\n", x, y, x - y);
}

int main() {
    // 声明函数指针变量
    funcPtr operation;

    // 指向 add 函数的地址
    operation = add;
    performOperation(5, 3, operation);

    // 指向 subtract 函数的地址
    operation = subtract;
    performOperation(5, 3, operation);

    return 0;
}

**代码解释及结果说明：**
- 在上面的代码中，通过 `typedef` 定义了一个名为 `funcPtr` 的函数指针类型，该类型可以指向接受两个整数参数并返回 `void` 的函数。
- `performOperation` 函数接受两个整数参数和一个函数指针作为参数，用于执行特定的操作。
- `main` 函数中演示了如何定义函数指针变量，以及如何将函数指针指向不同的函数，并调用 `performOperation` 函数执行操作。运行结果会输出相应的运算结果。

### 6.2 如何使用回调函数

回调函数是一种通过函数指针来调用的函数，常用于事件处理、异步操作等。在C语言中，可以通过回调函数实现对某个函数进行回调，以便在特定事件发生时执行相应的操作。

#include <stdio.h>

// 回调函数原型
typedef void (*callback)(int);

// 需要回调的函数
void performCallback(int value, callback cb) {
    printf("Performing callback on value: %d\n", value);
    cb(value);
}

// 回调函数实现
void callbackFunction(int value) {
    printf("Callback function invoked with value: %d\n", value);
}

int main() {
    // 调用 performCallback 函数，传入回调函数
    performCallback(42, callbackFunction);

    return 0;
}

**代码解释及结果说明：**
- 上面的示例中，定义了一个名为 `callback` 的函数指针类型，用于指向接受整数参数并返回 `void` 的函数。
- `performCallback` 函数接受一个整数参数和一个回调函数作为参数，在函数内部调用回调函数，并将参数传递给回调函数。
- `main` 函数中演示了如何使用 `performCallback` 函数，并将 `callbackFunction` 作为回调函数传入，当执行回调时，会输出相应的信息。

### 6.3 回调函数的应用场景

回调函数在C语言中被广泛应用，特别是在事件驱动编程、异步操作、框架设计等方面。通过回调函数，可以实现更加灵活和可扩展的程序结构，提高代码的复用性和可维护性。