C语言FCFS算法结构体初始化仅完成首迭代，程序异常终止求助

我正在用C语言实现FCFS（先来先服务）调度算法，用结构体存储进程信息，但初始化结构体时只能完成第一次循环迭代，第二次迭代程序就异常终止；调用display函数时也有类似问题（仅能显示3次迭代）。以下是相关代码和程序输出：

代码 #

struct proc{
    int id;
    int arrivalt;
    int burstt;
    int compt;
    int turnt;
    int waitt;
    bool completed;
};
void initialize(struct proc* x[],int n){
    int i;
    printf("n-%d\n",n);
    for(i=0;i<n;i++){
        printf("Entered\n");
        printf("id - %d\n",x[i]->id);
        x[i]->id=0;
        printf("new id-%d\n",x[i]->id);
        x[i]->arrivalt=0;
        x[i]->burstt=0;
        x[i]->compt=0;
        x[i]->turnt=0;
        x[i]->waitt=0;
        x[i]->completed=false;
    }
    return;
}
int main(){
    int n,i;
    struct proc *x[20];
    printf("Enter n");
    scanf("%d",&n);
    initialize(x,n);
}

初始化时程序输出 #

Enter n4
n-4
Entered
id - 56824
new id-0
Entered
id - 1220774728

--------------------------------
Process exited after 1.282 seconds with return value 3221225477
Press any key to continue . . .

调用display函数时程序输出 #

Enter n5
id      arrival burst   completion      turnaround      waiting
6702    972062720       0       0       0       0
1220774728      1076124811      611617608       2089502792      -1957933020     1213736036
686588744       889555784       1207959565      -2058878837     -14846784       93014224

--------------------------------
Process exited after 2.472 seconds with return value 3221225477
Press any key to continue . . .

核心问题是指针数组未分配有效内存：

• struct proc *x[20];定义的是一个指针数组，数组内的每个元素都是未初始化的野指针，指向内存中的随机地址。
• 第一次循环时可能巧合访问到暂时可用的内存，但第二次及后续访问野指针指向的非法内存时，操作系统会触发内存访问错误（返回值3221225477是Windows平台的STATUS_ACCESS_VIOLATION错误码，即段错误），直接终止程序。

有两种常用的修复方式：

方式一：使用结构体数组（推荐，无需手动管理内存） #

将指针数组改为结构体数组，直接分配栈内存，彻底避免野指针问题：

#include <stdbool.h>
#include <stdio.h>

struct proc{
    int id;
    int arrivalt;
    int burstt;
    int compt;
    int turnt;
    int waitt;
    bool completed;
};

// 修改函数参数为结构体数组，使用.访问成员
void initialize(struct proc x[], int n){
    int i;
    printf("n-%d\n",n);
    for(i=0;i<n;i++){
        printf("Entered\n");
        x[i].id = 0;
        printf("new id-%d\n",x[i].id);
        x[i].arrivalt = 0;
        x[i].burstt = 0;
        x[i].compt = 0;
        x[i].turnt = 0;
        x[i].waitt = 0;
        x[i].completed = false;
    }
}

int main(){
    int n,i;
    struct proc x[20]; // 定义结构体数组，直接分配栈内存
    printf("Enter n: ");
    scanf("%d",&n);
    initialize(x,n);
    return 0;
}

方式二：给指针数组的每个元素分配堆内存 #

如果必须使用指针数组，需在使用前为每个指针分配有效内存，用完后记得释放：

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

struct proc{
    int id;
    int arrivalt;
    int burstt;
    int compt;
    int turnt;
    int waitt;
    bool completed;
};

void initialize(struct proc* x[], int n){
    int i;
    printf("n-%d\n",n);
    for(i=0;i<n;i++){
        printf("Entered\n");
        x[i]->id = 0;
        printf("new id-%d\n",x[i]->id);
        x[i]->arrivalt = 0;
        x[i]->burstt = 0;
        x[i]->compt = 0;
        x[i]->turnt = 0;
        x[i]->waitt = 0;
        x[i]->completed = false;
    }
}

int main(){
    int n,i;
    struct proc *x[20];
    printf("Enter n: ");
    scanf("%d",&n);
    
    // 为每个指针分配堆内存，检查分配是否成功
    for(i=0;i<n;i++){
        x[i] = (struct proc*)malloc(sizeof(struct proc));
        if(x[i] == NULL){
            printf("内存分配失败\n");
            // 释放已分配的内存，避免泄漏
            for(int j=0;j<i;j++){
                free(x[j]);
            }
            return 1;
        }
    }
    
    initialize(x,n);
    
    // 后续业务逻辑...
    
    // 用完后释放所有堆内存
    for(i=0;i<n;i++){
        free(x[i]);
    }
    return 0;
}

• 使用bool类型时必须引入<stdbool.h>头文件，否则编译器会报错。
• 采用堆内存方案时，必须检查malloc的返回值，避免内存分配失败引发后续错误；同时要在程序结束前释放内存，防止内存泄漏。

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