【从0开始跟Chat老师学嵌入式 08】C语言进阶知识

本文链接：https://blog.youkuaiyun.com/yunyanwaner/article/details/142446267

小白：函数指针请举例说明具体使用方式

Chat老师：

函数指针在C语言中是一种特殊的指针类型，它指向的是一个函数，而不是一个普通的变量。通过函数指针，我们可以调用被指向的函数。它的使用场景包括：回调函数、实现多态、动态选择函数等。

函数指针的声明和使用

函数指针声明：
声明函数指针时，语法与普通指针类似，只不过函数指针指向的是函数，因此需要指定函数的返回类型和参数类型。
```
返回类型 (*指针名)(参数类型列表);
```
函数指针的使用：
通过函数指针调用函数，类似于调用普通函数，只不过是通过解引用指针来实现。

示例

以下是一个简单的示例，展示了如何使用函数指针：

#include <stdio.h>

// 定义两个简单的函数
int add(int a, int b) {
    return a + b;
}

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

// 定义一个函数，该函数接受函数指针作为参数
void operate(int (*operation)(int, int), int x, int y) {
    printf("Result: %d\n", operation(x, y));
}

int main() {
    // 声明函数指针
    int (*funcPtr)(int, int);
    
    // 指向add函数并调用
    funcPtr = &add;
    operate(funcPtr, 10, 5);  // 输出: Result: 15
    
    // 指向subtract函数并调用
    funcPtr = &subtract;
    operate(funcPtr, 10, 5);  // 输出: Result: 5

    return 0;
}

解释

int (*funcPtr)(int, int);：声明一个函数指针funcPtr，它指向一个返回值为int，并接受两个int参数的函数。
funcPtr = &add;：将add函数的地址赋给函数指针funcPtr。
operate(funcPtr, 10, 5);：通过传入funcPtr，动态选择调用哪个函数。

回调函数示例

在实际应用中，函数指针常用于回调函数，例如排序函数中动态传递比较函数：

#include <stdio.h>

// 定义比较函数
int compare(int a, int b) {
    return a - b;
}

// 定义排序函数，接受比较函数指针
void sort(int arr[], int n, int (*cmp)(int, int)) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (cmp(arr[j], arr[j + 1]) > 0) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {5, 2, 9, 1, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    sort(arr, n, compare);  // 传入比较函数
    
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    
    return 0;
}

此示例通过函数指针动态传递比较函数，实现了数组的排序。这种设计让代码更具灵活性和可扩展性。

小白：函数指针的应用场景有哪些

Chat老师：

函数指针的应用场景广泛，特别是在C语言和C++中，函数指针为程序设计提供了更多的灵活性和动态化处理。以下是函数指针常见的应用场景：

1. 回调函数

回调函数是一种将函数指针作为参数传递给另一个函数的技术，常用于异步操作、事件驱动开发等场景。典型的应用如：

事件处理：在GUI程序或嵌入式开发中，可以使用回调函数来处理用户交互事件（如按钮点击）。
异步操作：在网络编程中，回调函数常用于异步操作的结果处理。

例如，在一个排序函数中通过函数指针传递不同的比较函数，从而根据需要动态调整排序方式（升序或降序）：

#include <stdio.h>

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

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

void sort(int arr[], int n, int (*cmp)(int, int)) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (cmp(arr[j], arr[j + 1]) > 0) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

2. 实现多态

在C语言中没有类和继承的概念，但可以通过函数指针模拟多态。多态指的是不同对象可以根据上下文以不同的方式执行相同的操作。

不同的对象：可以定义不同的函数，通过函数指针来动态调用不同的行为。
策略模式：通过函数指针选择不同的策略或算法实现。

例如：

#include <stdio.h>

typedef struct {
    void (*draw)(void);  // 函数指针，指向不同图形的绘制函数
} Shape;

void drawCircle() {
    printf("Drawing Circle\n");
}

void drawSquare() {
    printf("Drawing Square\n");
}

int main() {
    Shape circle = { drawCircle };
    Shape square = { drawSquare };
    
    circle.draw();  // 输出：Drawing Circle
    square.draw();  // 输出：Drawing Square
    
    return 0;
}

3. 动态函数调用

在某些情况下，函数调用不能在编译时确定，可以通过函数指针在运行时动态选择函数调用。这在插件系统或动态库加载中尤为常见。

动态库调用：在使用动态链接库（如dlopen和dlsym）时，通常会通过函数指针调用动态加载的函数。

4. 函数表（跳转表）

函数表是一组函数指针数组，可以根据条件动态调用不同的函数。这种方式通常用于状态机、指令解析、操作调度等场景。

例如，一个简化的状态机：

#include <stdio.h>

void stateA() {
    printf("In State A\n");
}

void stateB() {
    printf("In State B\n");
}

void stateC() {
    printf("In State C\n");
}

int main() {
    // 定义函数指针数组
    void (*stateMachine[3])() = {stateA, stateB, stateC};
    
    // 根据输入调用不同的状态
    for (int i = 0; i < 3; i++) {
        stateMachine[i]();  // 动态调用
    }

    return 0;
}

5. 简化条件判断和选择结构

当需要根据不同条件执行不同的函数时，函数指针可以简化复杂的if-else或switch语句。通过将不同函数存储在指针数组中，能高效实现分支操作。

例如：

#include <stdio.h>

void func1() { printf("Function 1\n"); }
void func2() { printf("Function 2\n"); }
void func3() { printf("Function 3\n"); }

int main() {
    void (*funcArr[3])() = {func1, func2, func3};
    
    int choice = 1; // 假设用户选择了第二个函数
    funcArr[choice]();  // 动态调用对应的函数
    
    return 0;
}

6. 插件系统

函数指针是实现插件系统的核心。在大型应用中，可以将某些功能封装为模块或插件，主程序可以通过函数指针调用这些插件提供的功能，而无需在编译时确定具体实现。

7. 高阶函数

在某些语言中，高阶函数允许将一个函数作为参数传递给另一个函数，C语言通过函数指针实现类似的功能。通过这种方式，可以实现许多函数式编程的特性，如map、reduce等操作。例如：

#include <stdio.h>

void apply(int arr[], int n, void (*func)(int)) {
    for (int i = 0; i < n; i++) {
        func(arr[i]);
    }
}

void printElement(int x) {
    printf("%d\n", x);
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    apply(arr, 5, printElement);
    return 0;
}

8. 系统或库回调

函数指针广泛用于系统级和库回调函数，比如信号处理函数、线程库中的线程回调函数等。

信号处理：在处理信号时，可以通过signal()函数传递一个信号处理函数指针，用来捕捉和处理特定的系统信号。

#include <signal.h>
#include <stdio.h>

void handleSignal(int sig) {
    printf("Caught signal %d\n", sig);
}

int main() {
    signal(SIGINT, handleSignal);  // 传递回调函数指针
    while(1);  // 无限循环等待信号
    return 0;
}

总结

函数指针的应用场景非常广泛，尤其在需要灵活调用函数、提高代码复用性、减少冗余的场合，函数指针是强有力的工具。通过回调、动态调用、状态机、插件系统等方式，函数指针使程序更加动态化，并提升了代码的可维护性和扩展性。

小白：指针动态内存管理包含哪些知识点

Chat老师：

指针与动态内存管理是C语言及C++中的重要概念，涉及内存的分配、使用、和释放。动态内存管理允许程序根据运行时的需求来分配内存，而不是在编译时确定固定大小。以下是指针与动态内存管理中需要掌握的主要知识点：

1. 指针基础

指针定义和使用：指针是存储变量地址的变量。它们可以指向基本数据类型、结构体、数组或函数。
```
int a = 10;
int *ptr = &a;  // ptr指向变量a的地址
printf("%d", *ptr);  // 输出a的值：10
```
指针运算：指针可以进行算术运算，如增加、减少，以访问数组中的其他元素或连续的内存块。
```
int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;
printf("%d", *(ptr + 2));  // 输出第3个元素：3
```

2. 动态内存分配

动态内存分配允许在程序运行时分配所需的内存空间。C语言提供了四个标准库函数来管理动态内存：

malloc：分配未初始化的内存块
calloc：分配并初始化内存块
realloc：重新调整已分配的内存块大小
free：释放动态分配的内存

示例：

malloc：

int *ptr = (int *)malloc(5 * sizeof(int));  // 动态分配5个int大小的内存
if (ptr == NULL) {
    printf("Memory allocation failed!\n");
}

calloc：

int *ptr = (int *)calloc(5, sizeof(int));  // 分配并初始化为0的5个int大小的内存

realloc：

ptr = (int *)realloc(ptr, 10 * sizeof(int));  // 将原来的5个int大小扩展到10个int大小

free：

free(ptr);  // 释放动态分配的内存

3. 内存分配与释放的原则

分配的内存必须手动释放：C语言中的动态分配内存不会自动回收，程序员必须使用 free() 函数手动释放，否则会造成 内存泄漏。
避免重复释放：多次调用 free() 释放同一块内存是未定义行为，可能导致程序崩溃。
释放后置为 NULL：释放动态内存后，建议将指针置为 NULL，以避免悬挂指针（dangling pointer）的问题。
```
free(ptr);
ptr = NULL;  // 避免悬挂指针
```

4. 动态分配内存与指针的关系

动态分配的内存块通常通过指针来访问。

使用指针加偏移量或数组方式访问动态分配的内存，如：

int *ptr = (int *)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    ptr[i] = i * 10;  // 等价于 *(ptr + i) = i * 10;
}

5. 常见错误

内存泄漏：分配了内存但没有释放。例如，每次调用 malloc 分配内存但没有使用 free。
访问未初始化的内存：通过 malloc 分配的内存不会自动初始化，访问未初始化的内存可能会导致未定义行为。calloc 可以用来分配并初始化内存为0。
越界访问：动态内存分配后，访问超出范围的内存会导致未定义行为，甚至引发程序崩溃。
悬挂指针：指针指向已释放的内存区域，可能导致程序崩溃。

6. 动态数组

动态内存分配允许在运行时创建可变大小的数组：

int n;
printf("Enter the size of the array: ");
scanf("%d", &n);
int *arr = (int *)malloc(n * sizeof(int));  // 动态分配n个int大小的内存

动态数组的大小可以根据需求在运行时调整。

7. 结构体和动态内存

动态分配内存不仅可以用于基本数据类型，也可以用于复杂的数据类型如结构体：

struct Person {
    char name[50];
    int age;
};

struct Person *p = (struct Person *)malloc(sizeof(struct Person));  // 为结构体分配内存

动态分配的结构体可以通过指针访问其成员：

p->age = 30;  // 等价于 (*p).age = 30;

8. `realloc` 动态调整内存大小

realloc 用于调整已经分配的内存大小。它不仅可以扩大，还可以缩小内存区域：

int *arr = (int *)malloc(5 * sizeof(int));
arr = (int *)realloc(arr, 10 * sizeof(int));  // 扩展内存到10个int大小

realloc 如果成功扩展，会将数据从旧内存块复制到新内存块，旧块被自动释放。

9. 多维动态数组

C语言中也可以通过指针动态分配多维数组：

int **arr = (int **)malloc(rows * sizeof(int *));
for (int i = 0; i < rows; i++) {
    arr[i] = (int *)malloc(cols * sizeof(int));
}

这种方式可用于创建灵活的二维数组，行和列的大小在运行时可以动态调整。

10. 智能指针（C++）

在C++中，使用动态内存时可以借助 智能指针（如 std::unique_ptr 和 std::shared_ptr）来自动管理内存，避免手动调用 free。智能指针在对象离开作用域时自动释放内存，极大减少了内存泄漏的风险：

std::unique_ptr<int> ptr(new int(10));  // 动态分配并自动管理内存

总结

指针与动态内存管理涉及指针操作、动态分配函数（malloc、calloc、realloc、free）、以及如何高效、安全地使用这些函数。理解这些概念是避免内存泄漏、内存越界等常见问题的关键。

小白：如何避免内存泄漏和野指针

Chat老师：

避免内存泄漏和野指针是C和C++编程中的重要任务，确保内存管理的正确性能够提升程序的稳定性和性能。以下是一些有效的方法来避免这些问题：

1. 内存泄漏的避免

1.1 使用 `free` 释放内存

动态分配的内存必须手动释放，使用 malloc、calloc、realloc 分配的内存需要使用 free() 函数释放。

每次动态分配内存后，确保在不再使用时及时调用 free() 释放内存。
如果有多个可能退出的路径，确保所有路径都能够释放内存。

示例：

int *ptr = (int *)malloc(100 * sizeof(int));  // 分配内存
if (ptr == NULL) {
    // 错误处理
    return;
}
// 使用ptr...

free(ptr);  // 释放内存

1.2 避免重复释放

释放动态内存后，立即将指针置为 NULL。这可以避免重复释放同一块内存，防止程序崩溃。示例：

free(ptr);  // 释放内存
ptr = NULL; // 防止悬挂指针

1.3 对称的内存管理

坚持谁分配，谁释放的原则。确保每个 malloc() 或 calloc() 对应一个 free()。避免在多个地方管理同一块内存的释放。

1.4 记得释放所有分配的内存

特别是在循环或递归结构中动态分配内存时，确保在每次迭代或递归中都释放之前分配的内存，否则会导致内存泄漏。示例：

for (int i = 0; i < n; i++) {
    int *ptr = (int *)malloc(100 * sizeof(int));
    // 使用ptr...
    free(ptr);  // 每次迭代释放
}

1.5 避免在内存释放后继续使用

释放内存后，确保不再访问该内存区域。继续使用已释放的内存会引发未定义行为。

free(ptr);
// ptr[0] = 10;  // 错误，ptr已经被释放，不能再使用

1.6 工具和库的帮助

使用 内存泄漏检测工具，如 Valgrind、AddressSanitizer，来自动检测未释放的内存。
在 C++ 中使用 智能指针（如 std::unique_ptr 和 std::shared_ptr），可以自动管理动态分配的内存，防止内存泄漏。

2. 避免野指针

2.1 指针初始化

在定义指针时，如果没有立即赋值，应该将其初始化为 NULL，以便检测该指针是否有效。

int *ptr = NULL;  // 初始化为空指针

2.2 释放后将指针置为 `NULL`

释放动态内存后，将指针置为 NULL，这样可以避免悬挂指针。如果指针为 NULL，free() 不会对其做任何操作，因此重复 free() 是安全的。

free(ptr);
ptr = NULL;  // 防止使用悬挂指针

2.3 避免返回局部变量的地址

在函数中返回局部变量的地址是非常危险的，因为局部变量在函数返回后就不再存在，指向这些地址的指针将变为野指针。

错误示例：

int* getPtr() {
    int x = 10;
    return &x;  // 返回局部变量地址，x 在函数返回后不再有效
}

2.4 动态分配内存时，检查 `malloc` 是否成功

每次动态分配内存时，检查返回的指针是否为 NULL，以防分配失败时错误使用空指针。示例：

int *ptr = (int *)malloc(100 * sizeof(int));
if (ptr == NULL) {
    // 内存分配失败的处理
}

2.5 不要解引用空指针或悬挂指针

访问空指针或已释放的指针会导致程序崩溃。始终检查指针的有效性。

if (ptr != NULL) {
    *ptr = 10;  // 只有当ptr不为空时才能解引用
}

2.6 避免未初始化的指针

未初始化的指针可能指向任意内存地址，使用未初始化指针会导致未定义行为。确保每个指针在使用前已经被赋值有效的地址。

int *ptr;  // 未初始化
*ptr = 10;  // 错误，ptr没有指向有效的内存

2.7 使用智能指针（C++）

在 C++ 中，使用智能指针（如 std::unique_ptr、std::shared_ptr）来管理动态分配的内存。智能指针自动释放内存，可以有效避免野指针和内存泄漏。

示例：

std::unique_ptr<int> ptr(new int(10));  // 自动管理内存

2.8 避免指针算术错误

在指针操作中，确保指针指向有效的内存区域，特别是在数组或内存块访问时，避免越界访问。

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;
ptr += 10;  // 错误，越界访问

3. 总结

内存泄漏的预防：坚持为每个 malloc() 配对一个 free()，使用工具检测内存泄漏，使用智能指针进行内存管理。
避免野指针：确保指针初始化，释放后将指针置为 NULL，不返回局部变量地址，检查指针的有效性。

小白：为何要动态分配内存

Chat老师：

动态分配内存是C和C++等编程语言中的重要特性，它允许程序在运行时根据实际需求分配内存，而不是在编译时确定内存大小。动态内存分配提供了灵活性和高效性，特别是在处理未知或可变大小的数据时。以下是使用动态分配内存的原因和好处：

1. 灵活处理未知或可变大小的数据

在编写程序时，数据的大小可能在编译时无法确定，尤其是用户输入、读取文件或网络数据等场景。动态分配内存允许在运行时根据实际需求分配内存，而不是预先分配固定大小的内存。
例如，读取文件时，我们通常不知道文件的大小。在这种情况下，使用动态内存可以根据文件的大小动态调整内存分配。
```
char *buffer = (char *)malloc(file_size * sizeof(char));
```

2. 提高内存利用效率

如果在编译时为所有可能的数据场景分配固定大小的内存，会导致内存浪费。对于一些数据量较小的场景，预先分配的大量内存可能永远不会被使用。
动态分配内存根据实际需要分配，从而提高了内存的使用效率，减少浪费。例如，只在需要时分配和释放内存，有助于在内存有限的嵌入式系统或移动设备中优化资源使用。

3. 处理大型或不定长度的数据结构

动态内存分配使程序可以处理大型数据结构（如数组、链表、树等），这些数据结构的大小在编译时通常是不可预知的。例如，动态数组、链表、哈希表、二叉树等都需要在程序运行过程中动态调整其大小。
使用动态分配可以创建任意大小的数据结构，而不需要预先定义最大大小。
```
int *arr = (int *)malloc(n * sizeof(int));  // 动态分配n个元素的数组
```

4. 可变长度的字符串或数组

静态数组的大小必须在编译时确定，且无法动态扩展或缩减。对于长度变化的字符串或数组，使用动态内存可以在需要时灵活分配、扩展或缩小内存。

realloc 可以用来调整数组大小，而不是在内存不足时重新分配整个数组。例如：

int *arr = (int *)malloc(5 * sizeof(int));  // 初始分配5个int大小
arr = (int *)realloc(arr, 10 * sizeof(int));  // 扩展到10个int大小

5. 数据的动态生命周期管理

静态分配的内存会在程序结束后自动释放，而动态分配的内存允许开发者根据实际需要手动释放。这种灵活性使得可以根据程序的逻辑在合适的时机释放内存，避免不必要的内存占用。例如，在处理大量短期内存需求的场景中，可以通过动态分配内存来高效管理内存的使用。

例子：

创建对象或数据时动态分配内存，使用后手动释放，以控制对象的生命周期。

int *data = (int *)malloc(sizeof(int));
// 使用 data
free(data);  // 在合适的时机释放

6. 支持复杂的数据结构和递归

在递归程序中或复杂数据结构（如链表、树、图等）中，节点的数量通常无法预知。动态内存允许根据需要创建新的节点，并在节点不再需要时释放它们。

例如，链表的节点数在程序运行时可以动态增加：

struct Node {
    int data;
    struct Node *next;
};

struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));  // 动态分配链表节点

7. 跨函数返回动态分配的内存

静态分配的局部变量在函数结束后会失效，而动态分配的内存可以在函数间传递并使用。例如，通过函数返回指向动态分配内存的指针，允许在函数外部继续使用内存。
```
int* allocateArray(int n) {
    return (int*)malloc(n * sizeof(int));  // 返回动态分配的数组
}
```

8. 减少栈内存的压力

栈内存（Stack Memory）通常是有限的，过大的静态数组可能会导致栈溢出，尤其是对于嵌入式系统或递归深度较大的程序。动态内存分配可以将大数据结构放在堆内存中（Heap Memory），避免栈溢出风险。
```
// 静态数组可能导致栈溢出
int arr[1000000];

// 使用动态分配避免栈溢出
int *arr = (int *)malloc(1000000 * sizeof(int));
```