【C语言动态数组实现】：计算器多操作功能的实现技巧


参考资源链接：[编写一个支持基本运算的简单计算器C程序](https://wenku.csdn.net/doc/4d7dvec7kx?spm=1055.2635.3001.10343)
# 1. C语言动态数组基础

在计算机编程中，数组是一种数据结构，可以存储一系列相同类型的数据。在C语言中，数组的大小在编译时就固定了，这对于需要在运行时根据输入数据大小变化而改变数组容量的场景不够灵活。动态数组解决了这一问题，它允许我们在程序运行时动态地分配和调整数组的内存大小。

动态数组使用指针来管理内存，通过函数如`malloc()`来动态分配内存，`realloc()`来重新分配或调整已分配的内存块大小。动态数组的典型应用包括处理不确定数量的数据输入、实现高效的内存管理等。

在本章节中，我们将深入探讨如何在C语言中创建和使用动态数组，理解动态数组内存管理的基本原理，并介绍一些实际操作技巧。为初学者和希望进一步加深对C语言内存管理理解的开发者提供全面的知识体系。

示例代码如下，展示如何动态分配一个整型数组：

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

int main() {
    int *arr;
    int n = 5; // 假设我们需要存储5个整数

    // 动态分配内存
    arr = (int*)malloc(n * sizeof(int));
    if (arr == NULL) {
        printf("内存分配失败");
        return 1;
    }

    // 初始化数组
    for (int i = 0; i < n; i++) {
        arr[i] = i;
    }

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

    // 释放内存
    free(arr);

    return 0;
}

通过上述代码，我们首先使用`malloc()`函数分配了足够的内存空间来存储5个整数。然后，通过循环初始化数组，并使用另一个循环打印数组的元素。最后，使用`free()`函数释放了动态分配的内存。这样的操作允许我们在运行时根据需要处理大小可变的数据集。

# 2. 动态数组的内存管理

### 2.1 内存分配和释放机制

#### 2.1.1 malloc和free的使用方法

动态数组的内存管理是C语言程序设计中的重要组成部分，尤其当数组的大小在运行时才能确定时。`malloc` 和 `free` 函数是动态内存管理的核心，它们分别用于分配和释放内存。

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

int main() {
    int *arr;
    int n = 10; // 假设我们需要一个大小为10的数组

    // 分配内存
    arr = (int*)malloc(n * sizeof(int));
    if (arr == NULL) {
        // 内存分配失败
        return 1;
    }
    // 使用动态数组
    for (int i = 0; i < n; ++i) {
        arr[i] = i;
    }
    // 输出动态数组的值
    for (int i = 0; i < n; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 释放内存
    free(arr);

    return 0;
}

在上述代码中，`malloc` 被用来为一个包含10个整数的数组分配内存。如果分配成功，它将返回一个指向新分配的内存块的指针；如果失败，则返回 `NULL`。在使用完这块内存之后，`free` 函数被调用来释放它，以避免内存泄漏。

#### 2.1.2 内存泄漏的预防和检测

尽管 `malloc` 和 `free` 的使用看上去很简单，但很容易出错，导致内存泄漏。内存泄漏是指程序在申请了内存之后，未能正确释放，导致这部分内存不可再用的情况。

为了避免内存泄漏，我们需要确保每次成功调用 `malloc` 后，都有一个对应的 `free` 调用。一个常见的策略是使用智能指针，如 C++ 中的 `std::unique_ptr` 或者 C 的结构体包装 `malloc` 和 `free` 的调用。此外，代码审查和使用内存检测工具（如 Valgrind）也是预防和检测内存泄漏的有效手段。

### 2.2 动态数组的扩展和缩减

#### 2.2.1 realloc函数的原理与应用

当程序运行时需要对动态数组进行扩展或缩减时，使用 `realloc` 函数。`realloc` 不仅可以调整已分配内存块的大小，还可以在必要时将数据复制到新的内存块，并释放原来的内存块。

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

int main() {
    int *arr;
    int n = 5; // 初始数组大小
    int new_size = 10; // 新的数组大小

    // 分配内存
    arr = (int*)malloc(n * sizeof(int));
    if (arr == NULL) {
        return 1;
    }
    // 初始化数组
    for (int i = 0; i < n; ++i) {
        arr[i] = i;
    }

    // 扩展数组
    int *new_arr = (int*)realloc(arr, new_size * sizeof(int));
    if (new_arr == NULL) {
        free(arr); // 如果无法扩展，则释放原数组
        return 1;
    }
    arr = new_arr; // 更新指针

    // 继续使用新扩展的数组
    for (int i = n; i < new_size; ++i) {
        arr[i] = i;
    }

    // 输出扩展后的数组
    for (int i = 0; i < new_size; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 释放内存
    free(arr);

    return 0;
}

在上述代码中，`realloc` 首先尝试将原有的内存块大小扩展到新的大小。如果成功，`realloc` 返回新的内存块的指针。如果失败，则返回 `NULL`，并在原内存块上不执行任何操作。因此，当使用 `realloc` 时，我们需要检查返回值，并在必要时释放原有的内存块。

#### 2.2.2 动态数组容量调整策略

在实际应用中，动态数组的容量调整策略对性能有着重要影响。例如，如果我们频繁地对动态数组进行调整，可能会导致性能下降。这是因为 `realloc` 可能涉及到数据的复制和内存的重新分配。

一种常见的策略是预留额外的空间，这样就可以在不改变内存块的情况下，通过简单的指针操作来增加数组的有效长度。当预留空间耗尽时，再按照一个预设的比例（如1.5倍或2倍）进行扩展。

为了减少 `realloc` 的调用次数，我们可以预先估计数组可能达到的最大大小，并分配足够的内存。然而，这种方法可能会导致内存浪费。因此，实际的策略需要在时间和空间效率之间做出平衡。

### 2.3 指针数组与二维动态数组

#### 2.3.1 指针数组的创建和使用

指针数组是包含指针元素的数组，它可以用来存储指向其他数组或对象的指针。在处理动态数组时，指针数组非常有用，尤其是在我们需要动态创建多个数组时。

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

int main() {
    int rows = 3, cols = 3;
    int **matrix;

    // 分配指针数组内存
    matrix = (int**)malloc(rows * sizeof(int*));
    if (matrix == NULL) {
        return 1;
    }
    // 分配每行的内存
    for (int i = 0; i < rows; ++i) {
        matrix[i] = (int*)malloc(cols * sizeof(int));
        if (matrix[i] == NULL) {
            // 如果分配失败，释放之前分配的内存
            for (int j = 0; j < i; ++j) {
                free(matrix[j]);
            }
            free(matrix);
            return 1;
        }
    }
    // 初始化并使用二维数组
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            matrix[i][j] = i * cols + j;
        }
    }
    // 输出二维数组
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < rows; ++i) {