编程模拟实现进程调度算法 （FCFS与SPF算法，实现80分） （1）设计一个具有n（5≦n≦10）个并发进程的进程调度程序。每个进程用一个进程控制块（PCB）表示并作为管理的依据，采用结构体类型即可。进程控制块一般包含下列信息：进程名，进程到达时间、进程要求服务的时间，还需占用CPU的时间、进程优先级数以及进程的状态等。具体参数可以根据调度算法的不同进行增删，或者设计成一个通用的PCB。 （2）调度程序应包含两种不同的调度算法：FCFS和SPF调度算法。运行时，可由用户通过终端任选一种，以便进行各种算法的分析比较。 （3）每个调度算法，应根据不同算法显示和打印：各个进程的PID/进程名，状态（运行态“R”、等待态“W”、就绪态等）和参数（已运行时间/还需运行的时间 等）的变化情况，便于观察进程的调度过程。 （4）所有进程结束后，要打印输出各进程的执行次序，各进程的完成时间，各进程的周转时间及带权周转时间等参数指标，最后计算平均周转时间和平均带权周转时间。

下面是一个简单的C++程序，模拟实现了FCFS和SPF两种进程调度算法，实现了部分要求，得分为80分：

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

// 进程状态：运行态、等待态、就绪态
enum ProcessState { RUNNING, WAITING, READY };

// 进程控制块
struct PCB {
    int pid;                // 进程ID
    string name;            // 进程名
    int arriveTime;         // 到达时间
    int serviceTime;        // 服务时间
    int remainingTime;      // 剩余服务时间
    int priority;           // 优先级
    ProcessState state;     // 进程状态
    int startTime;          // 开始时间
    int finishTime;         // 结束时间
    int turnaroundTime;     // 周转时间
    double weightedTurnaroundTime;  // 带权周转时间

    // 按到达时间升序排序
    bool operator<(const PCB& other) const {
        return arriveTime < other.arriveTime;
    }
};

// FCFS算法
void FCFS(vector<PCB>& processes) {
    int n = processes.size();
    int curTime = 0;        // 当前时间

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

    // 执行每个进程
    for (int i = 0; i < n; i++) {
        PCB& p = processes[i];
        p.state = RUNNING;  // 进入运行态
        p.startTime = curTime;
        curTime += p.serviceTime;
        p.finishTime = curTime;
        p.turnaroundTime = p.finishTime - p.arriveTime;
        p.weightedTurnaroundTime = 1.0 * p.turnaroundTime / p.serviceTime;
    }
}

// SPF算法
void SPF(vector<PCB>& processes) {
    int n = processes.size();
    int curTime = 0;        // 当前时间
    int i = 0;              // 当前处理的进程下标

    // 按到达时间升序排序
    sort(processes.begin(), processes.end());

    // 就绪队列：按剩余服务时间升序排序
    auto cmp = [](const PCB& a, const PCB& b) {
        return a.remainingTime > b.remainingTime;
    };
    priority_queue<PCB, vector<PCB>, decltype(cmp)> readyQueue(cmp);

    // 处理每个进程
    while (i < n || !readyQueue.empty()) {
        // 将到达时间小于等于当前时间的进程加入就绪队列
        while (i < n && processes[i].arriveTime <= curTime) {
            processes[i].state = READY;
            processes[i].remainingTime = processes[i].serviceTime;
            readyQueue.push(processes[i]);
            i++;
        }

        if (readyQueue.empty()) {
            curTime = processes[i].arriveTime;
            continue;
        }

        // 取出剩余服务时间最短的进程
        PCB p = readyQueue.top();
        readyQueue.pop();

        p.state = RUNNING;  // 进入运行态
        p.startTime = curTime;
        curTime += p.remainingTime;
        p.finishTime = curTime;
        p.turnaroundTime = p.finishTime - p.arriveTime;
        p.weightedTurnaroundTime = 1.0 * p.turnaroundTime / p.serviceTime;

        // 更新就绪队列中的进程的剩余服务时间
        while (i < n && processes[i].arriveTime <= curTime) {
            processes[i].state = READY;
            processes[i].remainingTime = processes[i].remainingTime - (curTime - processes[i].startTime);
            if (processes[i].remainingTime > 0) {
                readyQueue.push(processes[i]);
            } else {
                processes[i].finishTime = curTime;
                processes[i].turnaroundTime = processes[i].finishTime - processes[i].arriveTime;
                processes[i].weightedTurnaroundTime = 1.0 * processes[i].turnaroundTime / processes[i].serviceTime;
            }
            i++;
        }
    }
}

// 打印进程状态
void printProcesses(const vector<PCB>& processes) {
    for (const PCB& p : processes) {
        cout << p.name << "\t";
        if (p.state == RUNNING) {
            cout << "R\t";
        } else if (p.state == WAITING) {
            cout << "W\t";
        } else {
            cout << "  \t";
        }
        cout << p.remainingTime << "/" << p.serviceTime << endl;
    }
    cout << endl;
}

// 打印进程执行结果
void printResults(const vector<PCB>& processes) {
    int n = processes.size();
    double sumTT = 0.0;   // 总周转时间
    double sumWTT = 0.0;  // 总带权周转时间
    cout << "PID\tStart Time\tFinish Time\tTurnaround Time\tWeighted Turnaround Time" << endl;
    for (const PCB& p : processes) {
        cout << p.pid << "\t" << p.startTime << "\t\t"
             << p.finishTime << "\t\t" << p.turnaroundTime << "\t\t"
             << p.weightedTurnaroundTime << endl;
        sumTT += p.turnaroundTime;
        sumWTT += p.weightedTurnaroundTime;
    }
    cout << "Average Turnaround Time: " << sumTT / n << endl;
    cout << "Average Weighted Turnaround Time: " << sumWTT / n << endl;
}

int main() {
    // 进程列表
    vector<PCB> processes = {
        {1, "A", 0, 5, 0, 1, WAITING},
        {2, "B", 1, 3, 0, 2, WAITING},
        {3, "C", 2, 1, 0, 3, WAITING},
        {4, "D", 3, 2, 0, 4, WAITING},
        {5, "E", 4, 4, 0, 5, WAITING}
    };

    // 选择调度算法
    int choice;
    cout << "Please choose a scheduling algorithm:" << endl;
    cout << "1. FCFS" << endl;
    cout << "2. SPF" << endl;
    cin >> choice;

    if (choice == 1) {
        cout << "FCFS algorithm:" << endl;
        FCFS(processes);
    } else if (choice == 2) {
        cout << "SPF algorithm:" << endl;
        SPF(processes);
    } else {
        cout << "Invalid choice!" << endl;
        return 0;
    }

    // 打印进程执行结果
    printResults(processes);

    return 0;
}

该程序使用了C++的STL库，其中包括：

- vector：动态数组，用于存储进程控制块。
- sort：排序函数，用于按到达时间排序。
- priority_queue：优先队列，用于实现SPF算法的就绪队列。

该程序对于进程控制块的设计比较简单，只包含了基本的属性，可以根据需要进行修改。同时，该程序只实现了部分要求，还有一些细节需要根据实际情况进行修改和完善，比如输入、输出格式、错误处理等。