在C语言while循环中存储数组索引值的方法及代码问题咨询

先拆解你代码里的核心问题，再给出可运行的完整实现方案：

一、当前代码的几个致命问题 #

• 未初始化变量k：你声明了int k但没给初始值，直接用A[k]会访问随机内存地址，大概率触发段错误。
• 动态数组空间不足：char *A = malloc(sizeof(*A));只分配了1个char的空间，循环中多次存储值会造成缓冲区溢出，属于严重的未定义行为。
• while循环条件不完整：代码末尾的while (abc[0][1]>1...缺少闭合逻辑，需要明确循环终止的完整条件（比如判断余数是否满足终止要求）。
• 不必要的floor函数使用：你的变量都是整数类型，floor((abc[1][1] - 1)/abc[0][1])可以用整数除法直接实现（整数除法本身会向下取整），避免浮点运算的开销和精度问题。

二、循环中存储索引值的正确思路 #

要在循环里持续存储值，需要做到这几点：

1. 初始化动态数组并设置合理的初始大小
2. 每次存储前检查空间是否足够，不足则用realloc扩容
3. 维护一个计数器（比如k）跟踪当前存储的位置
4. 循环结束后释放动态内存，避免内存泄漏

三、修复后的完整代码 #

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

int main() {
    int abc[2][2];
    int q, r, k = 0; // 初始化计数器k为0
    char *A = NULL;
    size_t arr_size = 2; // 初始数组大小

    // 初始化动态数组，检查分配是否成功
    A = malloc(arr_size * sizeof(*A));
    if (A == NULL) {
        perror("malloc failed");
        return 1;
    }

    // 初始化矩阵值
    abc[0][0] = 1;
    abc[1][0] = 0;
    abc[0][1] = 7;
    abc[1][1] = 480;

    do {
        if (abc[1][1] > abc[0][1]) {
            // 用整数除法替代floor，正整数场景下结果一致
            q = (abc[1][1] - 1) / abc[0][1];
            r = abc[1][1] - q * abc[0][1];
            abc[1][0] = q * abc[0][0] + abc[1][0];
            abc[1][1] = r;
        }
        if (abc[0][1] > abc[1][1]) {
            q = (abc[0][1] - 1) / abc[1][1];
            r = abc[0][1] - q * abc[1][1];
            abc[0][0] = q * abc[1][0] + abc[0][0];
            abc[0][1] = r;
        }

        // 检查数组空间，不足则扩容（每次扩容为原大小的2倍）
        if (k >= arr_size) {
            arr_size *= 2;
            char *temp = realloc(A, arr_size * sizeof(*A));
            if (temp == NULL) {
                perror("realloc failed");
                free(A);
                return 1;
            }
            A = temp;
        }

        // 存储当前索引值到数组A
        A[k] = abc[1][0];
        k++; // 计数器自增

    // 补充完整循环终止条件：当任意余数≤1时停止，可根据你的算法需求调整
    } while (abc[0][1] > 1 && abc[1][1] > 1);

    // 打印存储结果验证
    printf("Stored values in array A:\n");
    for (int idx = 0; idx < k; idx++) {
        printf("%d ", A[idx]);
    }
    printf("\n");

    // 释放动态内存
    free(A);
    return 0;
}

四、关键细节说明 #

• 动态扩容策略：每次把数组大小翻倍是高效的做法，能减少频繁扩容带来的性能损耗。
• 内存安全检查：每次调用malloc和realloc后都要判断返回值，防止内存分配失败导致程序崩溃。
• 整数除法优化：对于正整数，(a-1)/b的整数运算结果和floor((a-1)/b)完全一致，不需要引入浮点库。

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