请用c++设计一个程序1、 Simulate the operation of the round-robin algorithm for process scheduling. 2、 Create at least 15 processes and output their scheduling situation under the scheduling algorithm mentioned above and output it to the terminal to check the execution of the algorithm. 3、 The output should include the arrival time of the processes, the end time, and the average execution time.

好的，这是一个实现轮转调度算法的C++程序示例：

#include <iostream>
#include <vector>

using namespace std;

class Process {
public:
    int pid;
    int arrival_time;
    int burst_time;
    int remaining_time;
    int end_time;
    int waiting_time;
    int turnaround_time;

    Process(int pid, int arrival_time, int burst_time) {
        this->pid = pid;
        this->arrival_time = arrival_time;
        this->burst_time = burst_time;
        this->remaining_time = burst_time;
    }

    int execute(int time_slice) {
        if (remaining_time > time_slice) {
            remaining_time -= time_slice;
            return time_slice;
        } else {
            int time_executed = remaining_time;
            remaining_time = 0;
            return time_executed;
        }
    }

    bool is_finished() {
        return remaining_time == 0;
    }
};

void round_robin(vector<Process>& processes, int time_slice) {
    int current_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;
    int num_processes = processes.size();

    while (true) {
        bool all_finished = true;
        for (auto& p : processes) {
            if (p.arrival_time <= current_time && !p.is_finished()) {
                all_finished = false;
                int time_executed = p.execute(time_slice);
                current_time += time_executed;
                if (p.is_finished()) {
                    p.end_time = current_time;
                    p.waiting_time = p.end_time - p.burst_time - p.arrival_time;
                    p.turnaround_time = p.end_time - p.arrival_time;
                    total_waiting_time += p.waiting_time;
                    total_turnaround_time += p.turnaround_time;
                }
            }
        }

        if (all_finished) {
            break;
        }
    }

    double average_waiting_time = (double)total_waiting_time / num_processes;
    double average_turnaround_time = (double)total_turnaround_time / num_processes;

    cout << "Process\tArrival Time\tBurst Time\tEnd Time\tWaiting Time\tTurnaround Time" << endl;
    for (auto& p : processes) {
        cout << p.pid << "\t\t" << p.arrival_time << "\t\t" << p.burst_time << "\t\t" << p.end_time << "\t\t" << p.waiting_time << "\t\t" << p.turnaround_time << endl;
    }

    cout << "Average waiting time: " << average_waiting_time << endl;
    cout << "Average turnaround time: " << average_turnaround_time << endl;
}

int main() {
    vector<Process> processes = {
        Process(1, 0, 8),
        Process(2, 0, 4),
        Process(3, 0, 9),
        Process(4, 0, 5),
        Process(5, 0, 2),
        Process(6, 0, 4),
        Process(7, 0, 3),
        Process(8, 0, 7),
        Process(9, 0, 6),
        Process(10, 0, 1),
        Process(11, 0, 5),
        Process(12, 0, 3),
        Process(13, 0, 2),
        Process(14, 0, 6),
        Process(15, 0, 4),
    };

    int time_slice = 3;

    round_robin(processes, time_slice);

    return 0;
}

这个程序把15个进程作为参数传入，并且使用了3个时间片进行轮转调度。程序的输出将会包含每个进程的到达时间、结束时间、等待时间和周转时间，以及平均等待时间和周转时间。

注意：这只是一个简单的示例程序，真实的应用程序需要更加复杂的调度算法和更多的进程属性。同时，使用轮转调度算法需要注意时间片大小的选择，如果时间片太小，会增加上下文切换的开销；如果时间片太大，会增加进程等待时间。