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

以下是C++语言编写的RR时间片轮转与HPF优先级调度算法的实现：

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

using namespace std;

struct PCB {
    string name; // 进程名
    int arrive_time; // 到达时间
    int service_time; // 需要服务时间
    int priority; // 优先级
    int remaining_time; // 剩余需要占用CPU的时间
    int start_time; // 开始时间
    int end_time; // 结束时间
    int turnaround_time; // 周转时间
    double weighted_turnaround_time; // 带权周转时间
    string status; // 进程状态

    PCB(string name, int arrive_time, int service_time, int priority):
        name(name), arrive_time(arrive_time), service_time(service_time),
        priority(priority), remaining_time(service_time), start_time(0),
        end_time(0), turnaround_time(0), weighted_turnaround_time(0.0),
        status("W") {};

    // 重载运算符，按照优先级从高到低排序
    bool operator < (const PCB& other) const {
        return priority < other.priority;
    }
};

// RR时间片轮转调度算法
void rr_scheduling(vector<PCB>& processes, int time_slice) {
    queue<PCB> ready_queue; // 就绪队列
    int current_time = processes[0].arrive_time; // 当前时间
    int n = processes.size(); // 进程数
    int i = 0; // 当前处理的进程下标
    int cnt = 0; // 完成进程数

    while(cnt < n) {
        // 将到达时间小于等于当前时间的进程加入就绪队列
        while(i < n && processes[i].arrive_time <= current_time) {
            ready_queue.push(processes[i]);
            i++;
        }

        if(ready_queue.empty()) {
            current_time = processes[i].arrive_time;
            continue;
        }

        PCB current_process = ready_queue.front(); // 当前运行进程
        ready_queue.pop();

        current_process.status = "R"; // 进程状态改为运行态
        current_process.start_time = current_time; // 记录开始时间

        // 如果剩余时间小于等于时间片，则直接执行完
        if(current_process.remaining_time <= time_slice) {
            current_time += current_process.remaining_time;
            current_process.remaining_time = 0;
            current_process.end_time = current_time;
            current_process.turnaround_time = current_process.end_time - current_process.arrive_time;
            current_process.weighted_turnaround_time = (double)current_process.turnaround_time / current_process.service_time;
            current_process.status = "E"; // 进程状态改为结束态
            cnt++;
        }
        // 否则执行一个时间片
        else {
            current_time += time_slice;
            current_process.remaining_time -= time_slice;
            current_process.status = "W"; // 进程状态改为等待态
            ready_queue.push(current_process); // 将进程重新加入就绪队列
        }

        processes[current_process.priority - 1] = current_process; // 更新进程信息
    }
}

// HPF优先级调度算法
void hpf_scheduling(vector<PCB>& processes) {
    priority_queue<PCB> ready_queue; // 就绪队列
    int current_time = processes[0].arrive_time; // 当前时间
    int n = processes.size(); // 进程数
    int i = 0; // 当前处理的进程下标
    int cnt = 0; // 完成进程数

    while(cnt < n) {
        // 将到达时间小于等于当前时间的进程加入就绪队列
        while(i < n && processes[i].arrive_time <= current_time) {
            ready_queue.push(processes[i]);
            i++;
        }

        if(ready_queue.empty()) {
            current_time = processes[i].arrive_time;
            continue;
        }

        PCB current_process = ready_queue.top(); // 当前运行进程
        ready_queue.pop();

        current_process.status = "R"; // 进程状态改为运行态
        current_process.start_time = current_time; // 记录开始时间

        current_time += current_process.remaining_time;
        current_process.remaining_time = 0;
        current_process.end_time = current_time;
        current_process.turnaround_time = current_process.end_time - current_process.arrive_time;
        current_process.weighted_turnaround_time = (double)current_process.turnaround_time / current_process.service_time;
        current_process.status = "E"; // 进程状态改为结束态
        cnt++;

        processes[current_process.priority - 1] = current_process; // 更新进程信息
    }
}

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

    // 生成进程数据
    processes.push_back(PCB("P1", 0, 4, 1));
    processes.push_back(PCB("P2", 1, 3, 2));
    processes.push_back(PCB("P3", 2, 5, 3));
    processes.push_back(PCB("P4", 3, 2, 4));
    processes.push_back(PCB("P5", 4, 4, 5));
    processes.push_back(PCB("P6", 5, 6, 6));
    processes.push_back(PCB("P7", 6, 1, 7));
    processes.push_back(PCB("P8", 7, 2, 8));
    processes.push_back(PCB("P9", 8, 4, 9));
    processes.push_back(PCB("P10", 9, 3, 10));

    // 按照到达时间排序
    sort(processes.begin(), processes.end(), [](PCB a, PCB b) {
        return a.arrive_time < b.arrive_time;
    });

    // 调用RR时间片轮转调度算法
    rr_scheduling(processes, time_slice);

    // 打印各进程的执行次序，完成时间，周转时间和带权周转时间
    cout << "RR时间片轮转调度算法结果：" << endl;
    cout << "进程名\t开始时间\t结束时间\t周转时间\t带权周转时间" << endl;
    for(auto process : processes) {
        cout << process.name << "\t" << process.start_time << "\t\t"
             << process.end_time << "\t\t" << process.turnaround_time << "\t\t"
             << process.weighted_turnaround_time << endl;
    }
    cout << endl;

    // 调用HPF优先级调度算法
    hpf_scheduling(processes);

    // 打印各进程的执行次序，完成时间，周转时间和带权周转时间
    cout << "HPF优先级调度算法结果：" << endl;
    cout << "进程名\t开始时间\t结束时间\t周转时间\t带权周转时间" << endl;
    for(auto process : processes) {
        cout << process.name << "\t" << process.start_time << "\t\t"
             << process.end_time << "\t\t" << process.turnaround_time << "\t\t"
             << process.weighted_turnaround_time << endl;
    }

    // 计算平均周转时间和平均带权周转时间
    double avg_turnaround_time = 0.0, avg_weighted_turnaround_time = 0.0;
    for(auto process : processes) {
        avg_turnaround_time += process.turnaround_time;
        avg_weighted_turnaround_time += process.weighted_turnaround_time;
    }
    avg_turnaround_time /= n;
    avg_weighted_turnaround_time /= n;

    cout << "平均周转时间：" << avg_turnaround_time << endl;
    cout << "平均带权周转时间：" << avg_weighted_turnaround_time << endl;

    return 0;
}

程序中定义了一个PCB结构体来表示进程控制块，并根据不同调度算法的需要增减了一些成员变量。其中，RR时间片轮转调度算法使用了一个queue作为就绪队列，HPF优先级调度算法使用了一个priority_queue作为就绪队列。在调度算法的实现中，使用一个while循环不断处理就绪队列中的进程，直到所有进程都完成为止。

最后，程序输出各个进程的执行次序、完成时间、周转时间和带权周转时间，并计算平均周转时间和平均带权周转时间。