用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 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 quantum = 2; // 时间片大小

    // 轮转调度算法
    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}
    };

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

    // 输出结果
    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;
}

这个程序首先定义了一个 `Process` 结构体，用于存储进程的信息。然后，它实现了一个 `calculate_waiting_and_turnaround_time` 函数，用于计算每个进程的等待时间和周转时间。该函数首先初始化剩余执行时间和等待时间，然后使用一个队列 `Q` 存储待执行的进程。在算法的执行过程中，如果队列不为空，则取出队首的进程，如果该进程的剩余执行时间小于等于时间片大小，则执行完该进程，并计算其等待时间和周转时间，并将在该进程执行完之前到达的所有进程加入队列；否则，执行该进程一段时间后，将其重新加入队列，等待下一次调度。如果队列为空，则选择下一个到达时间最早的进程加入队列。

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

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