C语言中，二维数组和双重指针有啥区别

在C语言中，二维数组和双重指针（int**）虽然看起来相似，但它们在内存布局、访问方式和使用场景上有本质区别。以下是它们的核心区别：

1. 本质区别

2. 内存布局对比

（1）静态二维数组

int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};

内存布局（连续）：

[1][2][3][4][5][6]

• arr 的类型是 int (*)[3]，指向包含3个int的一维数组。

（2）动态双重指针

int** ptr = malloc(2 * sizeof(int*));
ptr[0] = malloc(3 * sizeof(int));
ptr[1] = malloc(3 * sizeof(int));

内存布局（可能不连续）：

ptr → [指针0] → [1][2][3]
       [指针1] → [4][5][6]

3. 访问方式的底层原理

（1）二维数组的访问，编译器自动计算偏移

• arr[i][j] 会被编译器转换为：

*(*(arr + i) + j)

// arr + i：跳过 i 行，每行大小为 N * sizeof(int)。
// *(arr + i) + j：在第 i 行内跳过 j 个元素。

（2）双重指针的访问，两次解引用

• ptr[i][j] 会被转换为：

*(*(ptr + i) + j)
    
// ptr + i：获取第 i 个指针的地址。
// *(ptr + i) + j：解引用得到第 i 行的指针，再跳过 j 个元素。

4. 函数传参区别

示例：传递二维数组

void print_array(int arr[][4], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 4; j++) printf("%d ", arr[i][j]);
    }
}

int main() {
    int a[3][4] = {0};
    print_array(a, 3);  // 列数必须匹配声明
}

1 2 3 4
5 6 7 8
9 10 11 12

示例：传递双重指针

void print_pointer(int **p, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) printf("%d ", p[i][j]);
    }
}
int main() {
    int **p = /* 动态分配 */;
    print_pointer(p, 3, 4);  // 行列可动态指定
}

完整示例与输出

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

// 传参必须声明列数
void print_array(int arr[][4], int rows)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

void init_ptr_array(int ** ptr, int rows, int cols)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            ptr[i][j] = (i * cols + j) * 2 + 1;
        }
    }
}

void print_ptr_array(int **ptr, int rows, int cols)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            printf("%d ", ptr[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

// 双重指针和二维数组的区别
int main()
{
    // 二维数组示例
    int arr[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    print_array(arr, 3); // 列数必须匹配声明

    // 双重指针示例
    int **matrix = (int **)malloc(3 * sizeof(int *));
    for (int i = 0; i < 3; i++)
    {
        matrix[i] = (int *)malloc(4 * sizeof(int)); // 分配每行的列
    }

    init_ptr_array(matrix, 3, 4);
    print_ptr_array(matrix, 3, 4);
    return 0;
}

1 2 3 4
5 6 7 8
9 10 11 12
1 3 5 7
9 11 13 15
17 19 21 23

5. 常见错误示例

错误1：将二维数组赋值给 int**

int arr[2][3] = {...};
int** p = arr;  // 错误！类型不兼容

原因：arr 是 int (*)[3]，而 p 是 int**，二者类型不同。

错误2：试图用 int** 访问静态二维数组

int** p = (int**)arr;
printf("%d", p[1][2]);  // 未定义行为！

原因：静态二维数组的内存是连续的，但 p[1][2] 会错误地解引用 arr 的内容作为地址。

6. 如何正确使用？

（1）静态二维数组 → 函数参数

void func(int arr[][3], int rows);  // 等价于 int (*arr)[3]

（2）动态模拟二维数组

int** ptr = malloc(rows * sizeof(int*));
for (int i = 0; i < rows; i++) {
    ptr[i] = malloc(cols * sizeof(int));
}
// 释放时需逐行 free

（3）强制转换的替代方案（不推荐）

若必须用 int** 访问静态数组，可以：

int* tmp = &arr[0][0];  // 展平为一维数组
int value = tmp[i * 3 + j];  // 手动计算偏移

7，关键区别总结

8. 总结

• 二维数组：内存连续，类型为 int (*)[N]，适合编译时已知维度的场景。
• 双重指针：内存可能不连续，类型为 int**，适合动态分配的“模拟二维数组”。
• 关键区别：内存布局和访问机制不同，直接混用会导致未定义行为。

理解这些区别能避免在动态/静态二维数组转换时出现内存错误！