写一个进程创建的c++代码，并结合选择的进程调度算法，完善PCB结构

好的，下面是一个简单的进程创建的C代码，并结合Round Robin进程调度算法：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>
#include<sys/types.h>
#include<sys/wait.h>

#define MAX 10

typedef struct PCB{
    pid_t pid;//pid
    int priority;//进程优先级
    int cpu_time;//占用CPU时间
    int run_time;//已运行时间
    int remain_time;//剩余运行时间
    int status;//进程状态
    struct PCB* next;//指向下一个进程的指针
}PCB;

int process_num = 0;
PCB* ready_list;//就绪队列的头指针
PCB* p;//指向当前进程的指针

void scheduling();//进程调度函数

void create_process(int priority, int cpu_time){//创建进程函数
    PCB* new_pcb = (PCB*)malloc(sizeof(PCB));
    new_pcb->pid = fork();
    if(new_pcb->pid == 0){//子进程
        signal(SIGSTOP, SIG_DFL);//子进程去掉SIGSTOP信号的处理函数
        while(1);//占用CPU
    }
    else if(new_pcb->pid < 0){//创建进程失败
        printf("Create process failed!\n");
        free(new_pcb);
        return;
    }
    else{//父进程
        new_pcb->priority = priority;
        new_pcb->cpu_time = cpu_time;
        new_pcb->run_time = 0;
        new_pcb->remain_time = cpu_time;
        new_pcb->status = 0;//新建进程状态为就绪
        new_pcb->next = ready_list;
        ready_list = new_pcb;//将新建进程加入就绪队列
        process_num++;//进程数量加1
        printf("Process[%d] created! priority=%d cpu_time=%d\n", new_pcb->pid, priority, cpu_time);
    }
}

void time_out(int sig){//设置时间片到时的处理函数
    p->remain_time -= 1;
    p->run_time += 1;
    if(p->remain_time == 0){
        printf("Process[%d] finished!\n", p->pid);
        waitpid(p->pid, NULL, 0);//等待进程结束
        p->status = -1;//进程状态改为退出
        process_num--;//进程数量减1
        free(p);//释放进程的PCB所占的空间
        if(ready_list != NULL) p = ready_list;//指向下一个进程的PCB
    }
    else{
        printf("Process[%d] time out!\n", p->pid);
        p->status = 1;//进程状态改为就绪
        p->next = ready_list;
        ready_list = p;//将进程加入就绪队列尾部
        p = ready_list;//指向就绪队列的头部
        ready_list = ready_list->next;//就绪队列指向下一个进程
    }
}

void scheduling(){
    int time_slice = 2;//时间片长度为2

    p = ready_list;
    signal(SIGALRM, time_out);//设置时间片到时的处理函数

    while(process_num > 0){
        if(p != NULL){//p不为空，说明就绪队列不为空
            if(p->status == 0){//进程状态为就绪
                p->status = 2;//进程状态改为运行
                kill(p->pid, SIGCONT);//恢复运行
                alarm(time_slice);//设置时间片长度
                pause();//等待时间片结束
            }
            else if(p->status == 1){//进程状态为阻塞
                p = p->next;
            }
            else if(p->status == -1){//进程状态为退出
                if(ready_list != NULL) p = ready_list;
            }
            else if(p->status == 2){//进程状态为运行
                kill(p->pid, SIGSTOP);//暂停运行
            }
        }
        else{//p为空，说明就绪队列为空
            printf("Ready list is empty!\n");
            sleep(1);
        }
    }
}

int main(){
    ready_list = NULL;
    int i, priority, cpu_time;
    for(i=0; i<MAX; i++){
        printf("Enter priority and cpu time of process[%d]:", i);
        scanf("%d%d", &priority, &cpu_time);
        create_process(priority, cpu_time);
    }
    scheduling();
    return 0;
}

在上面的代码中，我们进行了如下操作：

- 定义了进程控制块（PCB）结构，包含进程的pid、优先级、占用CPU时间、已运行时间、剩余运行时间和状态，以及指向下一个进程的指针。
- 定义了进程数量和就绪队列的头指针。
- 创建了进程的函数`create_process`，其中使用`fork()`系统调用创建子进程，并将子进程PID保存到新建PCB中，同时子进程占用CPU，父进程将新建PCB加入就绪队列中。
- 设置了时间片到时的处理函数`time_out`，当时间片到时时，将进程的剩余运行时间减1，已运行时间加1，如果剩余运行时间为0，就结束进程，将进程状态改为退出，进程数量减1，释放PCB的空间；否则，将进程状态改为就绪，将进程加入就绪队列尾部，就绪队列指向下一个进程。
- 设置了进程调度函数`scheduling`，在函数中定义了时间片长度，将当前进程指针p指向就绪队列的头部，设置时间片到时的处理函数和信号，循环执行进程调度操作，当进程数量为0时退出循环。在循环中，如果当前进程不为空，就根据进程状态选择不同的操作，如果进程状态为就绪，就将进程状态改为运行，恢复进程运行并设置时间片长度；如果进程状态为阻塞，就继续指向下一个进程；如果进程状态为退出，就将p指向就绪队列的头部；如果进程状态为运行，就暂停进程运行。如果当前进程为空，就输出就绪队列为空并休眠1秒。注：这里的调度算法是Round Robin算法。