嵌入式C语言：二维数组

一、二维数组的定义

二、内存布局

2.1. 内存布局特点

2.2. 内存布局示例

2.2.1. 数组元素地址

2.2.2. 内存布局图（简化表示）

2.3. 初始化对内存布局的影响

三、访问二维数组元素

3.1. 常规下标访问方式

3.2. 通过指针访问

3.2.1. 指向数组首元素的指针

3.2.2. 指向单行元素的指针

3.2.3. 指针数组访问方案（一种特殊的间接方式）

3.2.4. 动态二维数组与指针

3.3. 使用宏定义来简化访问

四、应用场景

4.1. 图像处理

4.2. 矩阵运算

4.3. 传感器数据采集与处理（矩阵形式的传感器阵列）

4.4. 游戏开发（简单的嵌入式游戏）

五、注意事项

5.1. 数组大小与内存限制

5.2. 数组越界访问

5.3. 作为函数参数传递

5.4. 初始化与赋值操作

5.5. 其它

在嵌入式 C 语言中，二维数组是一种非常有用的数据结构，用于存储和处理按行和列组织的数据。

一、二维数组的定义

在C语言中，二维数组的定义遵循以下语法结构：

数据类型 数组名[行数][列数];

int array[3][4];  // 声明一个3行4列的二维数组

定义了一个整数类型的二维数组array，包含3行4列，总共能存储12个整数。这些整数在内存中是线性排列的，即先填满第一行，再接着填充第二行，以此类推。

二、内存布局

二维数组在内存中的布局是按一维线性方式排列的，但逻辑上它呈现二维结构，即有行和列的概念。

2.1. 内存布局特点

连续存储：二维数组的所有元素在内存中都是连续存储的，没有间隔或空隙。
按行存储：二维数组通常是按行优先（row-major order）存储的。意味着数组的第一行完全存储在内存中，紧接着是第二行，依此类推。
元素地址计算：给定一个二维数组array[rows][cols]和一个元素array[i][j]，其内存地址可以通过以下方式计算（假设数组的起始地址为base_address，且每个元素的大小为element_size）：

address_of_element = base_address + (i * cols + j) * element_size

2.2. 内存布局示例

以int array[3][4]为例，假设每个整数元素占4个字节，且数组的起始地址为2000（仅为示例，实际地址由操作系统分配）。

2.2.1. 数组元素地址

array[0][0]的地址为2000。
array[0][1]的地址为2004（因为每个元素占4个字节）。
array[0][2]的地址为2008。
array[0][3]的地址为2012。
array[1][0]的地址为2016（跳过了第一行的4个元素）。
以此类推，array[2][3]的地址为2044。

2.2.2. 内存布局图（简化表示）

地址	元素
2000	array[0][0]
2004	array[0][1]
2008	array[0][2]
2012	array[0][3]
2016	array[1][0]
2020	array[1][1]
2024	array[1][2]
2028	array[1][3]
2032	array[2][0]
2036	array[2][1]
2040	array[2][2]
2044	array[2][3]

用代码来验证这种布局，可以通过指针运算：

#include <stdio.h>

int main() {
    int arr[3][4];
    int *p = (int *)arr;

    for (int i = 0; i < 3 * 4; i++) {
        p[i] = i;
    }

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("arr[%d][%d] = %d, address: %p\n", i, j, arr[i][j], &arr[i][j]);
        }
    }
    return 0;
}

先把二维数组当成一维数组，用指针给所有元素赋值，之后再用二维数组的常规访问方式输出每个元素及其地址。可以清晰看到，随着循环变量的推进，元素地址是连续递增的，充分证明了按行优先的存储特性。

这种内存布局的优势在于，访问同一行元素时，由于内存连续性，缓存命中率更高，能够加快数据访问速度。而且在进行一些底层算法，例如矩阵遍历、图像像素点扫描时，了解这种布局可以简化指针运算，高效处理数组元素。

2.3. 初始化对内存布局的影响

二维数组的初始化不会影响其内存布局方式，但会决定数组元素的初始值。

完全初始化：如果提供了足够的初始值来填充整个数组，那么这些值将按行顺序存放在内存中。

int array[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

部分初始化：如果只提供了部分初始值，那么未初始化的元素将被自动初始化为0（对于静态存储类型的数组）。这些0值也将按顺序存放在内存中。

int array[3][4] = {
    {1, 2},
    {3}
};
// 相当于：
// int array[3][4] = {
//     {1, 2, 0, 0},
//     {3, 0, 0, 0},
//     {0, 0, 0, 0}
// };

三、访问二维数组元素

3.1. 常规下标访问方式

使用下标访问二维数组元素是最直接且常见的方法：

array[i][j];  // i表示行索引，j表示列索引

索引都是从 0 开始计数。例如，对于前面定义的 array数组，要访问第二行第三列的元素，就用 matrix[1][2]，它的值是 6。

代码示例：

#include <stdio.h>
 
int main() {
    int matrix[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
 
    // 访问第二行第三列的元素
    int element = matrix[1][2];
    printf("Element at row 1, column 2: %d\n", element); // 输出: 7
 
    return 0;
}

在嵌入式系统中，这种精准访问常用于读取传感器矩阵数据、操控显示屏像素点等场景，每个元素对应一个物理量或者像素信息。

3.2. 通过指针访问

3.2.1. 指向数组首元素的指针

当我们有一个二维数组时，如int array[3][4];，可以定义一个指向其首元素的指针，即指向第一行第一个元素的指针：

int (*ptr)[4] = array; // ptr 是一个指向包含4个int元素的数组的指针

此时，ptr 可以被用来访问二维数组的元素。例如，ptr[i][j] 相当于 array[i][j]。这里，ptr[i] 是一个指向第 i 行第一个元素的指针（类型也是 int (*)[4]），然后 [j] 用于访问该行的第 j 个元素。

例如：

#include <stdio.h>
int main() {
    int arr[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    int (*q)[4];
    q = arr;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            // 通过指向行的指针访问元素并打印
            printf("%d ", (*(q + i))[j]);
        }
        printf("\n");
    }
    return 0;
}

3.2.2. 指向单行元素的指针

另一种方法是定义一个指向 int 的指针，并让它指向二维数组的第一个元素。这种方法需要更复杂的索引计算来访问特定的元素：

int *ptr = &array[0][0]; // ptr 是一个指向 int 的指针

要访问 array[i][j]，我们需要计算正确的偏移量：

int value = *(ptr + i * 4 + j); // 假设每行有4个元素

这里的 i * 4 + j 计算了从数组开始到 array[i][j] 的元素偏移量（假设数组是按行存储的，且每行有4个元素）。

例如：

#include <stdio.h>

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

    int *p = &matrix[0][0]; // 指向二维数组的第一个元素

    // 访问第二行第三列的元素
    int element = *(p + 1*4 + 2); // 1*4 + 2 是根据二维数组的内存布局计算出的偏移量
    printf("Element at row 1, column 2 (via pointer): %d\n", element); // 输出: 7

    return 0;
}

3.2.3. 指针数组访问方案（一种特殊的间接方式）

指针数组的构建：可以创建一个指针数组，其中每个指针指向二维数组的每一行。例如，对于int arr[3][4];，可以定义

int *row_pointers[3];

然后通过循环初始化每个指针，如

for (int i = 0; i < 3; i++) {row_pointers[i] = arr[i];}

这样，row_pointers数组中的每个元素就分别指向了arr的每一行。

元素访问方式：要访问二维数组中的元素arr[i][j]，可以使用

*(row_pointers[i] + j)

这里row_pointers[i]获取到指向第i行的指针，然后+ j进行列偏移，最后通过解引用*获取元素的值。

#include <stdio.h>
int main() {
    int arr[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    int *row_pointers[3];
    for (int i = 0; i < 3; i++) {
        row_pointers[i] = arr[i];
    }
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            // 通过指针数组访问元素并打印
            printf("%d ", *(row_pointers[i] + j));
        }
        printf("\n");
    }
    return 0;
}

3.2.4. 动态二维数组与指针

如果二维数组的大小是动态的，我们通常使用动态内存分配（如 malloc）来创建它，并使用指针来访问它。例如：

int rows = 3, cols = 4;
int **array = malloc(rows * sizeof(int*));
for (int i = 0; i < rows; i++) {
    array[i] = malloc(cols * sizeof(int));
}

// 访问元素
array[i][j] = some_value;

// 释放内存
for (int i = 0; i < rows; i++) {
    free(array[i]);
}
free(array);

在这种情况下，array 是一个指向指针的指针（即 int **），每个 array[i] 都是一个指向第 i 行第一个元素的指针（即 int *）。

使用指针访问的优势: 在嵌入式系统中，尤其是在资源有限的情况下，通过指针访问二维数组可以更灵活地操作内存。例如，在一些实时数据处理场景中，通过指针可以快速地遍历数组元素，减少不必要的下标计算开销。同时，在与硬件寄存器或者内存映射 I/O 设备交互时，指针访问方式可以更好地适应底层硬件的地址访问要求。

3.3. 使用宏定义来简化访问

为了方便和安全地访问二维数组元素，可以使用宏定义来封装访问逻辑。

宏定义与代码示例：

#include <stdio.h>

#define ACCESS_ELEMENT(array, row, column, width) ((array)[(row)*(width)+(column)])

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

    // 使用宏访问第二行第三列的元素
    int element = ACCESS_ELEMENT(matrix, 1, 2, 4); // 传入数组、行索引、列索引和列宽
    printf("Element at row 1, column 2 (via macro): %d\n", element); // 输出: 7

    return 0;
}

使用宏定义ACCESS_ELEMENT可以简化二维数组元素的访问，同时提高代码的可读性和可维护性。在需要频繁访问二维数组元素的嵌入式应用程序中，这种方法特别有用。