如何用指针遍历数组元素？三维数组指针求和循环出错求修正

问题1：用指针遍历3x3二维数组 #

C语言中，二维数组在内存中是连续存储的，比如int arr[3][3]的内存布局为：arr[0][0] → arr[0][1] → arr[0][2] → arr[1][0] → arr[1][1] → ... → arr[2][2]。因此可以通过指向数组首元素的指针，直接通过偏移或自增的方式遍历所有元素。

示例代码：

#include <stdio.h>

int main() {
    int arr[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}};
    int *ptr = &arr[0][0]; // 指向数组首元素的指针
    int total = 3 * 3; // 总元素数

    // 方法1：通过指针偏移遍历
    printf("通过指针偏移遍历：\n");
    for(int i = 0; i < total; i++) {
        printf("%d ", *(ptr + i));
    }
    printf("\n");

    // 方法2：通过指针自增遍历
    printf("通过指针自增遍历：\n");
    ptr = &arr[0][0]; // 重置指针位置
    for(int i = 0; i < total; i++) {
        printf("%d ", *ptr++);
    }
    printf("\n");

    return 0;
}

输出会按顺序打印1到9，证明可以通过指向首元素的指针循环遍历整个数组。

问题2：三维数组指针遍历求和的修正 #

你的代码存在两个核心问题：

1. sum未初始化，初始值为随机垃圾值，会导致求和结果错误；
2. 错误循环的指针偏移逻辑完全错误：嵌套循环中直接使用i/j/k作为偏移量，未计算元素在内存中的实际位置，导致重复计算或遗漏元素。

三维数组在内存中同样是连续存储的，总元素数为row * column * depth，以下是两种正确的遍历求和方式：

方法1：单循环直接遍历所有元素 #

利用内存连续性，通过总元素数直接遍历：

#include <stdio.h>

int main(){
    int A[50][50][50];
    int sum = 0; // 必须初始化sum
    int i,j,k;
    int row,column,depth;
    int *ptr;

    do {
        printf("请输入行数：");
        scanf("%d", &row);
        printf("请输入列数：");
        scanf("%d", &column);
        printf("请输入深度：");
        scanf("%d", &depth);

        if (row <= 0 || column <=0 || depth <=0) {
            printf("输入错误！请输入正整数\n");
        }
    } while (row <= 0 || column <=0 || depth <=0); // 修正循环条件，确保所有维度为正整数

    printf("行数：%d\n", row);
    printf("列数：%d\n", column);
    printf("深度：%d\n", depth);

    // 输入数组元素
    for (i=0;i<row ;i++) {
        for(j=0;j<column;j++){
            for(k=0;k<depth;k++){
                printf("请输入Array[%d][%d][%d]的值：", i + 1,j+1,k+1);
                scanf("%d", &A[i][j][k]);
            }
        }
    }

    ptr = &A[0][0][0];
    int total_elements = row * column * depth;
    // 单循环求和
    for(i=0; i<total_elements; i++){
        sum += *(ptr + i);
        // 也可以用sum += *ptr++;
    }

    printf("\n所有元素的和为：%d\n", sum);
    return 0;
}

方法2：嵌套循环配合指针自增 #

保持嵌套循环结构，每次访问元素后将指针自增，确保指向正确的下一个元素：

// 替换上述代码中的求和部分
sum = 0;
ptr = &A[0][0][0];
for(i=0; i<row; i++){
    for(j=0; j<column; j++){
        for(k=0; k<depth; k++){
            sum += *ptr++; // 访问当前元素后，指针移动到下一个元素
        }
    }
}

错误循环的问题分析 #

你的错误循环中，sum += *(ptr+i)、sum += *(ptr+j)、sum += *(ptr+k)都是基于原始指针ptr的偏移，相当于反复累加数组前几个元素，完全没有遍历到三维数组的所有元素。若要使用偏移量计算，正确的公式应为i * column * depth + j * depth + k，表示当前元素在连续内存中的位置：

sum += *(ptr + i*column*depth + j*depth + k);

不过这种写法不如指针自增直观。

内容的提问来源于stack exchange，提问作者jr.