写一个先来先服务算法的c++代码，要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等； 要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。

以下是一个简单的先来先服务算法的C++代码，可以模拟整个调度过程并输出每个时刻的进程运行状态，以及每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。

#include<iostream>
#include<queue>
#include<iomanip>
using namespace std;

// 进程结构体
struct Process {
    char name;      // 进程名
    int arrive;     // 到达时间
    int burst;      // 执行时间
    int start;      // 开始时间
    int finish;     // 完成时间
};

// 按到达时间排序的比较函数
bool cmp_arrive(const Process& a, const Process& b) {
    return a.arrive < b.arrive;
}

int main() {
    int n;      // 进程数量
    cout << "请输入进程数量：";
    cin >> n;

    // 输入进程信息
    vector<Process> processes(n);
    for (int i = 0; i < n; i++) {
        cout << "请输入进程名、到达时间、执行时间（用空格隔开）：";
        cin >> processes[i].name >> processes[i].arrive >> processes[i].burst;
    }

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

    // 用队列模拟调度过程
    queue<Process> q;
    int cur_time = 0;       // 当前时间
    for (int i = 0; i < n; i++) {
        // 处理等待队列中的进程
        while (!q.empty()) {
            Process p = q.front();
            q.pop();
            p.start = cur_time;
            p.finish = cur_time + p.burst;
            cout << "时刻" << cur_time << "：进程" << p.name << "开始运行，运行时间为" << p.burst << "个单位时间，完成时间为" << p.finish << endl;
            cur_time = p.finish;
        }
        // 处理新到达的进程
        if (processes[i].arrive > cur_time) {
            processes[i].start = processes[i].arrive;
            processes[i].finish = processes[i].arrive + processes[i].burst;
            cout << "时刻" << processes[i].arrive << "：进程" << processes[i].name << "开始运行，运行时间为" << processes[i].burst << "个单位时间，完成时间为" << processes[i].finish << endl;
            cur_time = processes[i].finish;
        }
        else {
            q.push(processes[i]);
        }
    }
    // 处理剩余的进程
    while (!q.empty()) {
        Process p = q.front();
        q.pop();
        p.start = cur_time;
        p.finish = cur_time + p.burst;
        cout << "时刻" << cur_time << "：进程" << p.name << "开始运行，运行时间为" << p.burst << "个单位时间，完成时间为" << p.finish << endl;
        cur_time = p.finish;
    }
    // 计算周转时间和带权周转时间
    double total_turnover = 0.0;
    double total_weighted_turnover = 0.0;
    for (int i = 0; i < n; i++) {
        int turnover = processes[i].finish - processes[i].arrive;
        double weighted_turnover = (double)turnover / processes[i].burst;
        processes[i].start = processes[i].start;
        processes[i].finish = processes[i].finish;
        cout << "进程" << processes[i].name << "的周转时间为" << turnover << "个单位时间，带权周转时间为" << fixed << setprecision(2) << weighted_turnover << endl;
        total_turnover += turnover;
        total_weighted_turnover += weighted_turnover;
    }
    // 计算平均周转时间和带权平均周转时间
    double avg_turnover = total_turnover / n;
    double avg_weighted_turnover = total_weighted_turnover / n;
    cout << "所有进程的平均周转时间为" << fixed << setprecision(2) << avg_turnover << "个单位时间，带权平均周转时间为" << fixed << setprecision(2) << avg_weighted_turnover << endl;

    return 0;
}

注意，此代码只是提供一个简单的先来先服务算法的实现，实际应用中还需要考虑更多因素，如进程优先级、抢占式调度等。