用c++语言实现进程调度实验：设计一个进程调度模拟器，使用时间片轮转（RR）算法，模拟几个进程的执行过程，并计算它们的等待时间和周转时间。简单一点

好的，以下是一个简单的基于C++的进程调度模拟器，使用时间片轮转算法实现。

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

struct Process {
    int pid; // 进程 ID
    int arrival_time; // 到达时间
    int burst_time; // 执行时间
    int remaining_time; // 剩余执行时间
    int waiting_time; // 等待时间
    int turnaround_time; // 周转时间
};

void calculate_waiting_and_turnaround_time(vector<Process>& processes, int quantum) {
    int n = processes.size();

    // 初始化剩余执行时间和等待时间
    for (int i = 0; i < n; i++) {
        processes[i].remaining_time = processes[i].burst_time;
        processes[i].waiting_time = 0;
    }

    queue<Process> Q; // 用于存储待执行的进程

    int time = 0; // 当前时间

    // 时间片轮转算法
    int i = 0; // 当前进程的索引
    while (!Q.empty() || i < n) {
        if (!Q.empty()) {
            Process p = Q.front();
            Q.pop();

            if (p.remaining_time <= quantum) {
                time += p.remaining_time;
                p.turnaround_time = time - p.arrival_time;
                p.waiting_time = p.turnaround_time - p.burst_time;
                for (int j = i + 1; j < n; j++) {
                    if (processes[j].arrival_time <= time) {
                        Q.push(processes[j]);
                    }
                }
            } else {
                time += quantum;
                p.remaining_time -= quantum;
                for (int j = i + 1; j < n; j++) {
                    if (processes[j].arrival_time <= time) {
                        Q.push(processes[j]);
                    }
                }
                Q.push(p);
            }
        } else {
            time = processes[i].arrival_time;
            Q.push(processes[i++]);
        }
    }
}

int main() {
    // 输入进程信息
    vector<Process> processes = {
        {1, 0, 10},
        {2, 1, 5},
        {3, 2, 8},
        {4, 3, 6},
        {5, 4, 9}
    };

    int quantum = 2; // 时间片大小

    // 计算等待时间和周转时间
    calculate_waiting_and_turnaround_time(processes, quantum);

    // 输出结果
    cout << "Process\tWaiting Time\tTurnaround Time" << endl;
    for (int i = 0; i < processes.size(); i++) {
        cout << processes[i].pid << "\t" << processes[i].waiting_time << "\t\t" << processes[i].turnaround_time << endl;
    }

    return 0;
}

这个程序与前一个程序的不同之处在于，它将时间片大小作为一个参数传递给 `calculate_waiting_and_turnaround_time` 函数，以便在轮转调度算法中使用。其他部分与前一个程序基本相同。

最后，程序输出每个进程的等待时间和周转时间。

希望这个例子能够帮助你理解时间片轮转算法的实现方法。