数组与函数实战：C语言核心技巧精讲

🎓博主介绍：精通 C、Python、Java、JavaScript 等编程语言，具备全栈开发能力。日常专注于分享编程干货、算法解析、项目实战经验，以及前沿技术动态。让我们一起在技术的道路上不断探索，共同成长！

数组与函数实战：C语言核心技巧精讲

1. 引言

在C语言的编程世界里，数组和函数是两个核心且强大的概念。数组能够将相同类型的数据有序存储，方便我们进行批量数据处理；而函数则能将一段具有特定功能的代码封装起来，提高代码的复用性和可维护性。掌握数组与函数的实战技巧，对于提升C语言编程能力至关重要。本文将深入剖析数组与函数的使用，结合丰富的代码示例和详细的步骤讲解，为技术人员带来一场干货满满的知识盛宴。

2. 数组基础回顾

2.1 一维数组的定义与初始化

一维数组是最基本的数组形式，它可以存储一组相同类型的数据。以下是一维数组的定义和初始化示例：

#include <stdio.h>

int main() {
    // 定义一个包含 5 个整数的数组并初始化
    int arr[5] = {1, 2, 3, 4, 5};

    // 输出数组元素
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    return 0;
}

步骤解析：

1. int arr[5] = {1, 2, 3, 4, 5};：定义了一个名为 arr 的整型数组，数组大小为 5，并使用花括号 {} 进行初始化，依次将 1、2、3、4、5 赋值给数组的每个元素。
2. for (int i = 0; i < 5; i++)：使用 for 循环遍历数组，循环变量 i 从 0 开始，每次递增 1，直到 i 等于 5 时停止循环。
3. printf("arr[%d] = %d\n", i, arr[i]);：在循环体中，使用 printf 函数输出数组元素的下标和对应的值。

2.2 二维数组的定义与初始化

二维数组可以看作是数组的数组，常用于表示矩阵等二维数据结构。以下是二维数组的定义和初始化示例：

#include <stdio.h>

int main() {
    // 定义一个 3 行 4 列的二维数组并初始化
    int matrix[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    // 输出二维数组元素
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("matrix[%d][%d] = %d\n", i, j, matrix[i][j]);
        }
    }

    return 0;
}

步骤解析：

1. int matrix[3][4] = {...};：定义了一个名为 matrix 的二维整型数组，它有 3 行 4 列。使用嵌套的花括号 {} 对数组进行初始化，每行的数据用内层花括号括起来。
2. 外层 for 循环 for (int i = 0; i < 3; i++) 用于遍历二维数组的行，内层 for 循环 for (int j = 0; j < 4; j++) 用于遍历每行的列。
3. printf("matrix[%d][%d] = %d\n", i, j, matrix[i][j]);：在嵌套循环体中，使用 printf 函数输出二维数组每个元素的行下标、列下标和对应的值。

3. 数组作为函数参数

3.1 一维数组作为函数参数

当需要对数组进行处理时，可以将数组作为函数参数传递给函数。以下是一个计算一维数组元素之和的示例：

#include <stdio.h>

// 函数声明
int sumArray(int arr[], int size);

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int size = 5;

    // 调用函数计算数组元素之和
    int result = sumArray(arr, size);

    printf("数组元素之和为: %d\n", result);

    return 0;
}

// 函数定义
int sumArray(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

步骤解析：

1. int sumArray(int arr[], int size);：函数声明，表明 sumArray 函数接受一个整型数组 arr 和一个表示数组大小的整数 size 作为参数，返回一个整型值。
2. 在 main 函数中，定义了一个包含 5 个元素的数组 arr 和数组大小 size，然后调用 sumArray 函数并将返回值存储在 result 变量中。
3. int sumArray(int arr[], int size)：函数定义，在函数内部，使用 for 循环遍历数组，将每个元素累加到 sum 变量中，最后返回 sum。

3.2 二维数组作为函数参数

二维数组作为函数参数时，需要指定除第一维以外的其他维度大小。以下是一个计算二维数组元素之和的示例：

#include <stdio.h>

// 函数声明
int sumMatrix(int matrix[][4], int rows);

int main() {
    int matrix[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    int rows = 3;

    // 调用函数计算二维数组元素之和
    int result = sumMatrix(matrix, rows);

    printf("二维数组元素之和为: %d\n", result);

    return 0;
}

// 函数定义
int sumMatrix(int matrix[][4], int rows) {
    int sum = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 4; j++) {
            sum += matrix[i][j];
        }
    }
    return sum;
}

步骤解析：

1. int sumMatrix(int matrix[][4], int rows);：函数声明，matrix 是一个二维整型数组，第二维大小为 4，rows 表示数组的行数。
2. 在 main 函数中，定义了一个 3 行 4 列的二维数组 matrix 和行数 rows，调用 sumMatrix 函数计算数组元素之和并存储在 result 变量中。
3. int sumMatrix(int matrix[][4], int rows)：函数定义，使用嵌套的 for 循环遍历二维数组，将每个元素累加到 sum 变量中，最后返回 sum。

4. 函数返回数组

4.1 返回静态数组

在C语言中，函数不能直接返回数组，但可以返回指向数组的指针。以下是一个返回静态数组的示例：

#include <stdio.h>

// 函数声明
int* getStaticArray();

int main() {
    int *arr = getStaticArray();

    // 输出数组元素
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    return 0;
}

// 函数定义
int* getStaticArray() {
    static int arr[5] = {1, 2, 3, 4, 5};
    return arr;
}

步骤解析：

1. int* getStaticArray();：函数声明，表明 getStaticArray 函数返回一个指向整型的指针。
2. 在 main 函数中，调用 getStaticArray 函数并将返回的指针存储在 arr 变量中，然后使用 for 循环输出数组元素。
3. int* getStaticArray()：函数定义，定义了一个静态整型数组 arr，静态数组的生命周期是整个程序运行期间，因此可以安全地返回其指针。

4.2 返回动态分配的数组

也可以通过动态内存分配的方式返回数组。以下是一个返回动态分配数组的示例：

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

// 函数声明
int* getDynamicArray(int size);

int main() {
    int size = 5;
    int *arr = getDynamicArray(size);

    // 输出数组元素
    for (int i = 0; i < size; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

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

    return 0;
}

// 函数定义
int* getDynamicArray(int size) {
    int *arr = (int*)malloc(size * sizeof(int));
    if (arr == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    for (int i = 0; i < size; i++) {
        arr[i] = i + 1;
    }
    return arr;
}

步骤解析：

1. int* getDynamicArray(int size);：函数声明，getDynamicArray 函数接受一个整数 size 作为参数，返回一个指向整型的指针。
2. 在 main 函数中，定义数组大小 size，调用 getDynamicArray 函数获取动态分配的数组指针，使用 for 循环输出数组元素，最后使用 free 函数释放动态分配的内存，避免内存泄漏。
3. int* getDynamicArray(int size)：函数定义，使用 malloc 函数动态分配 size 个整型元素的内存空间，检查内存分配是否成功，若失败则输出错误信息并终止程序。然后使用 for 循环初始化数组元素，最后返回数组指针。

5. 实战案例：冒泡排序

5.1 冒泡排序算法原理

冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

5.2 代码实现

#include <stdio.h>

// 冒泡排序函数
void bubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换 arr[j] 和 arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[5] = {5, 4, 3, 2, 1};
    int size = 5;

    // 调用冒泡排序函数
    bubbleSort(arr, size);

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

    return 0;
}

步骤解析：

1. void bubbleSort(int arr[], int size)：定义冒泡排序函数，使用嵌套的 for 循环遍历数组。外层循环控制排序的轮数，内层循环比较相邻元素并交换位置。
2. 在 if (arr[j] > arr[j + 1]) 条件判断中，如果前一个元素大于后一个元素，则使用临时变量 temp 交换它们的位置。
3. 在 main 函数中，定义一个未排序的数组 arr 和数组大小 size，调用 bubbleSort 函数对数组进行排序，最后使用 for 循环输出排序后的数组。

6. 结论

通过本文的学习，我们深入了解了C语言中数组与函数的核心技巧，包括数组的定义与初始化、数组作为函数参数、函数返回数组以及实战案例冒泡排序。数组和函数的灵活运用能够让我们更加高效地处理数据和实现复杂的功能。希望大家通过不断地实践和探索，熟练掌握这些技巧，提升自己的C语言编程水平。