C语言-08_高级C语言特征

目标

• 1、C语言中的动态内存分配
• 2、C语言中的可变参数函数
• 3、C语言中的递归函数

一、C语言中的动态内存分配

1.1 动态内存分配的基本概念

在C语言中，动态内存分配是在程序运行时动态地从堆（Heap）中分配和释放内存的过程。这个过程是通过一组特殊的函数完成的，这些函数被统称为动态内存管理函数。

动态内存分配的主要优点是可以根据实际需要灵活地分配内存。例如，如果你在编写一个处理大量数据的程序，你可能无法预先知道你需要多少内存。这时，就可以使用动态内存分配，根据程序的实际需要在运行时分配内存。这样不仅可以避免浪费内存，也有利于处理大量数据。

然而，动态内存分配也需要谨慎使用。分配的内存如果不再使用，必须手动释放，否则会造成内存泄漏，可能会消耗大量的系统资源，甚至使程序崩溃。因此，合理使用动态内存分配函数，是编程过程中需要注意的重要事项。

1.2 动态内存分配的函数

在C语言中，动态内存分配的操作是通过一组库函数完成的，这些函数都定义在 stdlib.h 头文件中。下面是这些函数的概述：

1. malloc(size_t size)：分配指定字节数的未初始化的内存。如果分配成功，返回一个指向被分配内存的首字节的指针。如果分配失败，返回 NULL。
2. calloc(size_t nmemb, size_t size)：为指定数量的元素分配内存，每个元素的大小由 size 参数指定。这个函数和 malloc 的主要区别是，calloc 分配的内存会被初始化为零。如果分配成功，返回一个指向被分配内存的首字节的指针。如果分配失败，返回 NULL。
3. realloc(void *ptr, size_t size)：重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存区域的大小。新的大小由 size 参数指定。如果 ptr 是 NULL，realloc 的行为就像 malloc 一样。如果 size 是零，realloc 的行为就像 free 一样。如果内存被成功分配，则返回指向它的指针，否则返回 NULL，原来的内存区域保持不变。
4. free(void *ptr)：释放之前通过 malloc、calloc 或 realloc 分配的内存。

使用这些函数进行动态内存分配时，应始终检查返回值以确定是否分配成功。在使用完毕后，应始终记得使用 free 函数释放内存，以防止内存泄漏。

1.3 如何使用 malloc 进行内存分配

malloc 是 C 语言中用于动态内存分配的函数，它的功能是在程序运行过程中从堆区申请一块指定大小的内存。其函数原型如下：

void* malloc(size_t size);

malloc 是 C 语言中用于动态内存分配的函数，它的功能是在程序运行过程中从堆区申请一块指定大小的内存。其函数原型如下：

cCopy code
void* malloc(size_t size);

其中，size_t 类型表示要分配的内存的大小（以字节为单位）。如果内存分配成功，malloc 会返回一个指向新分配内存的指针，如果分配失败（如内存不足），则返回 NULL。

下面是一个简单的示例，说明如何使用 malloc 函数：

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 分配存储 10 个 int 的内存空间
    int *array = malloc(10 * sizeof(int));

    // 检查是否分配成功
    if (array == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    // 使用分配的内存
    for (int i = 0; i < 10; i++) {
        array[i] = i;
    }

    // 打印数组内容
    for (int i = 0; i < 10; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");

    // 使用完毕后，释放内存
    free(array);

    return 0;
}

注意，在使用完毕后，需要用 free 函数释放 malloc 分配的内存，防止内存泄漏。

1.4 如何使用 calloc 进行内存分配

calloc 是 C 语言中用于动态内存分配的函数，与 malloc 相比，calloc 会额外将分配的内存初始化为 0。其函数原型如下：

void* calloc(size_t num, size_t size);

其中，num 表示要分配的元素的数量，size 表示每个元素的大小（以字节为单位）。如果内存分配成功，calloc 会返回一个指向新分配内存的指针，如果分配失败（如内存不足），则返回 NULL。

下面是一个简单的示例，说明如何使用 calloc 函数：

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 分配 10 个 int 大小的内存空间，并初始化为 0
    int *array = calloc(10, sizeof(int));

    // 检查是否分配成功
    if (array == NULL) {
        printf("内存分配失败！\n");
        return 1;
    }

    // 打印数组内容，可以看到所有元素都被初始化为 0
    for (int i = 0; i < 10; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");

    // 使用完毕后，释放内存
    free(array);

    return 0;
}

与 malloc 类似，在使用完毕后，需要用 free 函数释放 calloc 分配的内存，防止内存泄漏。

1.5 如何使用 realloc 改变已分配的内存大小

realloc 是C语言中用于改变已分配内存大小的函数。其函数原型如下：

void* realloc(void* ptr, size_t new_size);

其中，ptr 是指向已分配内存的指针，new_size 是新的内存大小（以字节为单位）。如果成功，realloc 返回一个指向新内存的指针，这可能与原来的指针相同，也可能不同。如果失败，它将返回 NULL，而原来的内存区域不会改变。

下面是一个简单的示例，说明如何使用 realloc 函数：

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 使用 malloc 分配 10 个 int 大小的内存空间
    int *array = malloc(10 * sizeof(int));

    // 检查是否分配成功
    if (array == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // 填充数组
    for (int i = 0; i < 10; i++) {
        array[i] = i;
    }

    // 使用 realloc 扩大内存空间到 20 个 int
    array = realloc(array, 20 * sizeof(int));

    // 检查是否重新分配成功
    if (array == NULL) {
        printf("Memory reallocation failed!\n");
        return 1;
    }

    // 填充新分配的数组部分
    for (int i = 10; i < 20; i++) {
        array[i] = i;
    }

    // 打印数组内容
    for (int i = 0; i < 20; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");

    // 使用完毕后，释放内存
    free(array);

    return 0;
}

在使用 realloc 时，如果新的大小小于原来的大小，超过新大小的部分可能会被丢弃。如果新的大小大于原来的大小，新分配的部分不会被初始化，它的内容是未定义的。请注意，如果 realloc 失败，原始指针仍然有效，需要使用者进行额外的错误处理。

1.6 如何使用 free 释放动态分配的内存

free 是一个标准库函数，用于释放之前通过 malloc，calloc 或 realloc 动态分配的内存。它的函数原型是：

void free(void *ptr);

• 头文件：#include <stdlib.h>
• 函数原型：void free(void *ptr);
• 函数参数：ptr 是指向要释放的动态分配的内存的指针。
• 返回值：此函数没有返回值。

一旦我们的程序完成了对动态分配内存的使用，我们应当使用 free 函数释放这部分内存，避免内存泄露。调用 free 函数后，ptr 所指向的内存区域被标记为可用，可以被后续的 malloc、calloc 或 realloc 函数调用重新使用。

示例程序：

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 使用 malloc 为一个整数变量分配内存
    int *p = malloc(sizeof(int));

    if (p == NULL) {
        printf("Failed to allocate memory.\n");
        return 1;
    }

    // 在动态分配的内存中存储一个数值
    *p = 5;
    printf("The integer value is %d\n", *p);

    // 使用 free 释放动态分配的内存
    free(p);

    return 0;
}

在这个示例中，我们首先使用 malloc 为一个整数变量分配内存。然后，我们检查是否成功分配了内存。如果内存分配失败，malloc 将返回 NULL。然后，我们在分配的内存中存储了一个整数值，并打印出来。最后，我们调用 free 函数，释放了先前分配的内存。

1.7 动态内存分配的错误和调试

动态内存分配是一个强大但也容易出错的工具。以下是一些常见的动态内存分配错误以及如何调试和避免它们的方法：

1.7.1 内存泄露

定义：当我们使用 malloc、calloc 或 realloc 分配的内存在使用完后没有被 free 释放，这部分内存就无法被再次使用，即发生了内存泄露。

调试和解决方法：我们需要在每次动态分配内存后，跟踪所有的内存，确保在不再使用这块内存时，适时地调用 free 函数进行释放。使用像 Valgrind 这样的内存检测工具，可以帮助我们找出程序中的内存泄露。

1.7.2 野指针

定义：指向已经被释放或者未被有效初始化的内存的指针被称为野指针。对野指针的解引用可能会导致程序崩溃。

调试和解决方法：我们需要在每次调用 free 后，将对应的指针设置为 NULL，以防止产生野指针。在使用指针前，我们也应该确保它已被有效初始化，指向了合法的内存区域。

1.7.3 内存越界

定义：如果我们试图访问超出了我们通过 malloc、calloc 或 realloc 分配的内存范围的内存，就会发生内存越界。

调试和解决方法：我们需要确保在使用动态分配的内存时，始终保持在合法的内存范围内。一种常见的方法是始终通过变量来记录数组的长度或动态分配的内存的大小，并在每次访问时都进行边界检查。

二、C语言中的可变参数函数

2.1 可变参数函数的基本概念

在C语言中，可变参数函数是一种可以接受不定数量参数的函数。这些函数通常用于处理不确定数量的参数，比如printf和scanf函数。使用可变参数函数可以使程序更灵活，因为它们可以处理不同类型和数量的参数。

2.2 使用可变参数函数

C语言使用 <stdarg.h> 头文件提供了一种处理可变参数列表的方法。这个头文件包含了处理可变参数的宏定义和类型。

2.3 可变参数函数的创建和使用

可变参数函数在声明时使用省略号 ... 来表示可变参数列表。例如，函数 int func(int, ...) 是一个接受至少一个 int 类型参数的可变参数函数。使用 va_start、va_arg 和 va_end 宏可以分别开始获取可变参数、获取参数值和结束获取。

2.4 可变参数函数的实例

以下是一个可变参数函数的例子，这个函数接受两个参数：参数数量和参数列表，然后返回所有参数的平均值。

#include <stdarg.h>
#include <stdio.h>

double average(int num, ...) {
    va_list valist;
    double sum = 0.0;
    int i;

    /* 为 num 个参数初始化 valist */
    va_start(valist, num);

    /* 访问所有赋给 valist 的参数 */
    for (i = 0; i < num; i++) {
       sum += va_arg(valist, int);
    }
  
    /* 清理为 valist 保留的内存 */
    va_end(valist);

    return sum/num;
}

int main() {
    printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));
    printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));
}

在上述代码中，函数 average 使用了 va_list 类型的变量 valist 来保存获取到的参数，va_start 用来开始获取参数，va_arg 用来获取参数值，va_end 用来结束获取。最后，函数返回所有参数值的平均数。

2.5 可变参数函数的注意事项

虽然可变参数函数提供了强大的功能，但在使用时也要注意以下几点：

• 可变参数函数不能进行类型检查，所以在传递参数时要特别注意参数的类型和数量，避免出错。
• 使用 va_start 开始获取参数后，必须使用 va_end 结束获取，否则可能导致程序崩溃。
• 可变参数列表中不能有数组和函数类型的参数，但可以有指向数组或函数的指针类型参数。

三、C语言中的递归函数

3.1 递归函数的基本概念

递归函数是在一个函数的定义中直接或间接地调用函数自身的一种方法。递归函数可以用来解决一些可以逐级分解为相同性质子问题的问题，比如阶乘、斐波那契数列等。使用递归函数可以使代码更为简洁，问题更易理解。

递归通常有两个基本元素：基础情况（base case）和递归情况（recursive case）。基础情况通常是指问题最简单的情况，即可以直接得出结果，无需再次递归的情况。递归情况则是指问题复杂的情况，这种情况下的问题需要再次调用函数自身来进行解决。

当递归函数被调用时，函数会检查是否满足基础情况。如果满足，函数将直接返回基础情况的结果。如果不满足基础情况，函数将进行递归调用，尝试解决更小规模的同类问题，直到满足基础情况为止。

3.2 递归函数的应用

递归函数广泛应用在各种需要将复杂问题分解为较小同类问题的场景中。以下是递归函数的一些典型应用：

1. 阶乘计算：阶乘是递归函数的经典应用。例如，计算 n 的阶乘可以通过计算 n-1 的阶乘乘以 n 来完成，基本情况就是 n=1 时，阶乘值为 1。
2. 斐波那契数列：斐波那契数列是另一个常见的递归应用。斐波那契数列中的每个数字是前两个数字的和，基本情况是序列的前两个数字为 0 和 1。
3. 汉诺塔问题：汉诺塔是一个经典的递归问题。它是关于三个柱子和一堆大小不同的盘子的谜题，目标是将所有的盘子从一个柱子移动到另一个柱子，同时遵循一个规则：一次只能移动一个盘子，并且任何时候都不能将一个较大的盘子放在较小的盘子上。这个问题可以使用递归函数来解决。
4. 二叉树遍历：在计算机科学中，递归在树和图的数据结构中也有广泛的应用。例如，二叉树的遍历就是一个递归过程，因为我们可以将一个大的二叉树分解为较小的左子树和右子树，然后对这些子树进行递归处理。

以上就是一些递归函数的典型应用。递归的思想在算法设计中非常重要，因为它能够将复杂问题简化为可以管理的小问题。然而，虽然递归能够让算法看起来更加简洁，但是它也可能导致额外的计算开销，因为每次函数调用都会消耗一些计算资源。因此，在设计递归函数时，我们需要在易用性和效率之间进行权衡。

递归函数在编程中的使用主要涉及到以下几个步骤：

1. 确定递归函数的功能：首先需要明确你的递归函数需要完成什么功能，如计算阶乘、斐波那契数列、二叉树遍历等。
2. 编写递归出口：递归出口是递归函数最先能够直接返回结果的条件，也叫做基本情况(base case)。如计算阶乘时，如果n等于1，就直接返回1。
3. 编写递归表达式：递归表达式用于把大问题化为小问题，使得递归能够持续进行。如计算阶乘时，n的阶乘可以表示为n乘以(n-1)的阶乘。

下面是一个使用C语言编写的计算阶乘的递归函数示例：

#include <stdio.h>

long long factorial(int n) {
    if (n == 0)  // 递归出口
        return 1;
    else
        return n * factorial(n - 1);  // 递归表达式
}

int main() {
    int number = 5;
    printf("%d 的阶乘是 %lld\n", number, factorial(number));
    return 0;
}