C++实现roundrobin算法。要求使用fork（）， 译文：输出应该包括流程的到达时间、结束时间和平均执行时间。

下面是使用fork()函数实现roundrobin算法的C++代码：

#include <iostream>
#include <vector>
#include <unistd.h> // for fork() function

using namespace std;

struct Process {
    int id;
    int arrival_time;
    int burst_time;
    int remaining_time;
    int completion_time;
    int turnaround_time;
    int waiting_time;
};

void roundRobin(vector<Process>& processes, int quantum) {
    int n = processes.size();
    int time = 0;
    int completed = 0;
    vector<int> burst_remaining(n);
    vector<int> start_time(n);
    vector<int> end_time(n);
  
    for (int i = 0; i < n; i++) {
        burst_remaining[i] = processes[i].burst_time;
        start_time[i] = -1;
    }
  
    while (completed != n) {
        for (int i = 0; i < n; i++) {
            if (burst_remaining[i] > 0) {
                if (start_time[i] == -1) {
                    start_time[i] = time;
                }
                if (burst_remaining[i] <= quantum) {
                    time += burst_remaining[i];
                    burst_remaining[i] = 0;
                    processes[i].completion_time = time;
                    processes[i].turnaround_time = processes[i].completion_time - processes[i].arrival_time;
                    processes[i].waiting_time = processes[i].turnaround_time - processes[i].burst_time;
                    completed++;
                } else {
                    time += quantum;
                    burst_remaining[i] -= quantum;
                }
            }
        }
    }
  
    // print results
    printf("Process\tArrival Time\tBurst Time\tCompletion Time\tTurnaround Time\tWaiting Time\n");
    for (int i = 0; i < n; i++) {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].id, processes[i].arrival_time, processes[i].burst_time, processes[i].completion_time, processes[i].turnaround_time, processes[i].waiting_time);
    }
  
    // calculate average waiting time and turnaround time
    double avg_waiting_time = 0;
    double avg_turnaround_time = 0;
    for (int i = 0; i < n; i++) {
        avg_waiting_time += processes[i].waiting_time;
        avg_turnaround_time += processes[i].turnaround_time;
    }
    avg_waiting_time /= n;
    avg_turnaround_time /= n;
    printf("\nAverage Waiting Time: %f\n", avg_waiting_time);
    printf("Average Turnaround Time: %f\n", avg_turnaround_time);
}

int main() {
    // initialize processes
    vector<Process> processes = {
        {1, 0, 10},
        {2, 4, 5},
        {3, 5, 3},
        {4, 7, 8},
        {5, 10, 6}
    };

    int quantum = 2;
  
    // create child process
    pid_t pid = fork();
  
    if (pid == 0) {
        // child process
        roundRobin(processes, quantum);
        exit(0);
    } else if (pid > 0) {
        // parent process
        wait(NULL);
    } else {
        cerr << "Fork failed" << endl;
        return 1;
    }
  
    return 0;
}

在这个程序中，我们首先定义一个结构体Process，用来存储每个进程的信息，包括进程ID、到达时间、执行时间等等。然后实现了一个roundRobin()函数，该函数接受一个Process向量和一个时间片大小作为参数，并使用round-robin算法对这些进程进行调度。在调度过程中，我们使用fork()函数创建了一个子进程来执行roundRobin()函数，然后在父进程中等待子进程完成。

在roundRobin()函数中，我们使用了四个向量：burst_remaining、start_time、end_time和processes。其中burst_remaining向量存储每个进程的剩余执行时间，start_time向量存储每个进程的开始执行时间，end_time向量存储每个进程的结束执行时间，processes向量存储所有进程的信息。

在调度过程中，我们对每个进程进行循环，如果该进程的剩余执行时间大于0，则进行调度。如果该进程的开始执行时间为-1，则说明该进程尚未开始执行，我们将当前时间记录为该进程的开始执行时间。如果该进程的剩余执行时间小于等于时间片大小，则将其执行完毕并更新其完成时间、周转时间和等待时间。否则，我们消耗一个时间片，并减少该进程的剩余执行时间。

在调度完成后，我们打印所有进程的信息，并计算平均等待时间和周转时间，然后将结果输出。

最后，我们使用fork()函数创建了一个子进程来执行roundRobin()函数，并在父进程中等待子进程完成。