C语言单级指针和双重指针访问二维数组的区别

在C语言中，单级指针和双重指针访问二维数组的方式有本质区别，主要体现在内存访问方式、语法形式和适用场景上。以下是详细对比：

1. 内存访问机制的区别

(1) 单级指针也叫一重指针（int*）访问二维数组

• 原理：将二维数组视为连续的一维内存块，通过手动计算偏移量访问。
• 内存布局：

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

内存实际存储：

[1][2][3][4][5][6]  // 完全连续

• 访问方式：

int *p = &arr[0][0]; // 或 (int*)arr
int val = p[row * 列数 + col]; // 手动计算偏移

(2) 双重指针（int**）访问二维数组

• 原理：通过两次解引用访问，第一层指针指向行，第二层指针指向列。
• 内存布局（动态分配时）：

int **ptr = malloc(2 * sizeof(int*)); // 分配行指针
for (int i = 0; i < 2; i++) 
    ptr[i] = malloc(3 * sizeof(int)); // 每行单独分配

内存可能不连续：

ptr[0] → [1][2][3]  // 第一行（地址A）
    ptr[1] → [4][5][6]  // 第二行（地址B，可能与A不连续）

• 访问方式：

int val = ptr[row][col]; // 自动解引用

2. 语法形式的区别

操作	一重指针 (int*)	双重指针 (int**)
初始化	int *p = &arr[0][0];	int **ptr = malloc(...);
访问元素	p[row*3 + col]	ptr[row][col]
内存连续性	连续	可能不连续
适用对象	静态二维数组	动态分配的"伪二维数组"

3. 关键区别总结

特性	一重指针访问	双重指针访问
内存布局	连续存储，直接计算偏移	行指针指向分散的内存块
访问效率	更高（单次内存计算）	较低（需两次解引用）
灵活性	必须已知列数	可动态调整行/列
类型安全	需强制类型转换（如(int*)arr）	直接匹配动态分配结构
越界风险	需手动控制偏移量	依赖分配的行/列边界

4. 代码示例对比

(1) 一重指针访问静态二维数组

#include <stdio.h>

int main() {
    int arr[2][3] = {{1,2,3}, {4,5,6}};
    int *p = (int*)arr; // 强制转换为一重指针

    // 访问arr[1][2]（第二行第三列）,  offset = i * cols + j
    int val = p[1 * 3 + 2]; // 手动计算偏移
    printf("%d\n", val);  // 输出6

    return 0;
}

(2) 双重指针访问动态分配的"二维数组"

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

int main()
{
    int **ptr = malloc(2 * sizeof(int *));
    for (int i = 0; i < 2; i++)
    {
        ptr[i] = malloc(3 * sizeof(int));
        for (int j = 0; j < 3; j++)
        {
            ptr[i][j] = i * 3 + j + 1; // 填充数据
        }
    }

    // 访问ptr[1][2]（第二行第三列）
    printf("%d\n", ptr[1][2]); // 输出6

    // 释放内存
    for (int i = 0; i < 2; i++)
        free(ptr[i]);
    free(ptr);
    return 0;
}

5. 常见问题

Q1: 能否用双重指针直接指向静态二维数组？

int arr[2][3] = {{1,2,3}, {4,5,6}};
int **ptr = arr; // 错误！类型不匹配

不能。

• 原因：静态二维数组名是int (*)[3]（数组指针），不是int**。
• 修正：

int (*ptr)[3] = arr; // 正确：数组指针
printf("%d\n", ptr[1][2]); // 合法访问

Q2: 哪种方式性能更好？

• 一重指针：适合固定大小的二维数组，访问更快（直接计算偏移）。
• 双重指针：适合动态分配的场景，灵活性高，但访问需两次解引用。

6. 总结

• 一重指针：操作静态二维数组的首选，需手动计算偏移，内存连续高效。
• 双重指针：用于动态分配的"伪二维数组"，语法更直观，但内存可能不连续。

根据需求选择合适的方式：
✅ 静态数组、追求性能 → 一重指针
✅ 动态分配、需要灵活性 → 双重指针