c++语言编程模拟实现进程调度算法（RR时间片轮转与HPF优先级调度算法)（1）设计一个具有n（10≦n）个并发进程的进程调度程序。每个进程用一个进程控制块（PCB）表示。进程控制块一般包含下列信息：进程名，进程到达时间、进程要求服务的时间、进程优先级数、还需占用CPU的时间以及进程的状态等。具体参数可以根据调度算法的不同进行增删，或者设计成一个通用的PCB。 （2）调度程序采用RR时间片轮转调度算法进行调度。运行时，应能显示和打印：时间片大小（可自定，或按规律设定），各个进程的PID，状态（运行态“R”、等待态“W” 、就绪态等）和参数（已运行时间/还需运行的时间 等）的变化情况，便于观察进程的调度过程。 （4）所有进程结束后，要打印输出各进程的执行次序，各进程的完成时间，各进程的周转时间及带权周转时间等参数指标，最后计算平均周转时间和平均带权周转时间。

以下是基于RR时间片轮转调度算法的C++代码实现：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

struct PCB {   // 进程控制块
    string name;   // 进程名
    int arriveTime;   // 进程到达时间
    int serviceTime;   // 进程要求服务的时间
    int priority;   // 进程优先级数
    int remainTime;   // 还需占用CPU的时间
    int startTime;   // 进程开始时间
    int finishTime;   // 进程完成时间
    int turnaroundTime;   // 周转时间
    double weightedTurnaroundTime;   // 带权周转时间
    char state;   // 进程状态，R：运行态，W：等待态，F：完成态
};

bool compareArriveTime(PCB a, PCB b) {   // 按照进程到达时间排序
    return a.arriveTime < b.arriveTime;
}

void printProcessInfo(PCB p) {   // 打印进程信息
    cout << p.name << " ";
    cout << p.startTime << " ";
    cout << p.finishTime << " ";
    cout << p.turnaroundTime << " ";
    cout << p.weightedTurnaroundTime << endl;
}

void roundRobin(vector<PCB>& processes, int quantum) {   // RR时间片轮转调度算法
    int n = processes.size();
    int currentTime = 0;
    int finishedNum = 0;
    vector<PCB> readyQueue;   // 就绪队列
    PCB runningProcess;   // 正在运行的进程

    // 按照进程到达时间排序
    sort(processes.begin(), processes.end(), compareArriveTime);

    // 初始化进程状态
    for (int i = 0; i < n; i++) {
        processes[i].state = 'W';
        processes[i].remainTime = processes[i].serviceTime;
    }

    // RR时间片轮转调度
    while (finishedNum < n) {
        // 将已到达的进程加入就绪队列
        for (int i = 0; i < n; i++) {
            if (processes[i].arriveTime <= currentTime && processes[i].state == 'W') {
                readyQueue.push_back(processes[i]);
                processes[i].state = 'R';
            }
        }

        // 如果当前没有进程在运行，从就绪队列中取出第一个进程开始运行
        if (runningProcess.name == "" && !readyQueue.empty()) {
            runningProcess = readyQueue[0];
            readyQueue.erase(readyQueue.begin());
            runningProcess.startTime = currentTime;
            runningProcess.state = 'R';
            // 如果进程剩余时间小于时间片，直接运行完
            if (runningProcess.remainTime <= quantum) {
                currentTime += runningProcess.remainTime;
                runningProcess.remainTime = 0;
                runningProcess.finishTime = currentTime;
                runningProcess.turnaroundTime = runningProcess.finishTime - runningProcess.arriveTime;
                runningProcess.weightedTurnaroundTime = (double)runningProcess.turnaroundTime / runningProcess.serviceTime;
                runningProcess.state = 'F';
                finishedNum++;
            }
            // 如果进程剩余时间大于时间片，运行一个时间片
            else {
                currentTime += quantum;
                runningProcess.remainTime -= quantum;
                runningProcess.state = 'W';
                readyQueue.push_back(runningProcess);
                runningProcess.name = "";
            }
        }
        // 如果当前有进程在运行，继续运行
        else if (runningProcess.name != "") {
            // 如果进程剩余时间小于时间片，直接运行完
            if (runningProcess.remainTime <= quantum) {
                currentTime += runningProcess.remainTime;
                runningProcess.remainTime = 0;
                runningProcess.finishTime = currentTime;
                runningProcess.turnaroundTime = runningProcess.finishTime - runningProcess.arriveTime;
                runningProcess.weightedTurnaroundTime = (double)runningProcess.turnaroundTime / runningProcess.serviceTime;
                runningProcess.state = 'F';
                finishedNum++;
                runningProcess.name = "";
            }
            // 如果进程剩余时间大于时间片，运行一个时间片
            else {
                currentTime += quantum;
                runningProcess.remainTime -= quantum;
                runningProcess.state = 'W';
                readyQueue.push_back(runningProcess);
                runningProcess.name = "";
            }
        }
        // 如果当前没有进程在运行且就绪队列为空，时间流逝
        else {
            currentTime++;
        }
    }

    // 打印进程执行顺序及各项参数指标
    cout << "进程执行顺序及各项参数指标：" << endl;
    cout << "名称 开始时间 完成时间 周转时间 带权周转时间" << endl;
    for (int i = 0; i < n; i++) {
        printProcessInfo(processes[i]);
    }

    // 计算平均周转时间和平均带权周转时间
    double avgTurnaroundTime = 0;
    double avgWeightedTurnaroundTime = 0;
    for (int i = 0; i < n; i++) {
        avgTurnaroundTime += processes[i].turnaroundTime;
        avgWeightedTurnaroundTime += processes[i].weightedTurnaroundTime;
    }
    avgTurnaroundTime /= n;
    avgWeightedTurnaroundTime /= n;
    cout << "平均周转时间：" << avgTurnaroundTime << endl;
    cout << "平均带权周转时间：" << avgWeightedTurnaroundTime << endl;
}

int main() {
    int n = 10;   // 进程数
    vector<PCB> processes(n);
    int quantum = 2;   // 时间片大小

    // 初始化进程信息
    processes[0] = { "P1", 0, 8, 3, 0, 0, 0, 0, 0, 'W' };
    processes[1] = { "P2", 1, 4, 2, 0, 0, 0, 0, 0, 'W' };
    processes[2] = { "P3", 2, 9, 1, 0, 0, 0, 0, 0, 'W' };
    processes[3] = { "P4", 3, 5, 4, 0, 0, 0, 0, 0, 'W' };
    processes[4] = { "P5", 4, 2, 5, 0, 0, 0, 0, 0, 'W' };
    processes[5] = { "P6", 5, 6, 3, 0, 0, 0, 0, 0, 'W' };
    processes[6] = { "P7", 6, 7, 2, 0, 0, 0, 0, 0, 'W' };
    processes[7] = { "P8", 7, 1, 5, 0, 0, 0, 0, 0, 'W' };
    processes[8] = { "P9", 8, 3, 3, 0, 0, 0, 0, 0, 'W' };
    processes[9] = { "P10", 9, 5, 4, 0, 0, 0, 0, 0, 'W' };

    roundRobin(processes, quantum);

    return 0;
}

其中，我们定义了一个结构体PCB来表示进程控制块，包含了进程的各项信息和状态。我们使用vector来存储所有进程，然后按照进程到达时间排序，便于后续的调度。在RR时间片轮转调度算法中，我们使用了一个就绪队列来存储已到达且还未运行完的进程，然后按照时间片大小依次运行每个进程。如果某个进程在一个时间片内运行完，则该进程状态变为完成态。如果某个进程在一个时间片内未运行完，则该进程状态变为等待态，加入就绪队列的末尾。如果当前没有进程在运行且就绪队列为空，则时间流逝。当所有进程都运行完后，我们打印出进程执行顺序及各项参数指标，并计算出平均周转时间和平均带权周转时间。

另外，需要注意的是，在本题中我们使用了一个固定的进程集合来测试代码，实际应用中进程数和进程信息可能需要从文件或者命令行参数中读入。