用c++实现fcfs处理机调度算法，输入包括进程数量，到达时刻，服务时间，开始执行时刻，完成时刻，计算出各自的周转时间和带权周转时间

FCFS（First-Come, First-Served，先来先服务）调度算法是一种简单的线性调度策略，它按照进程到达的时间顺序进行处理。以下是使用C++实现的基本步骤：

#include <iostream>
#include <vector>

struct Process {
    int pid;        // 进程ID
    int arrival_time; // 到达时刻
    int burst_time;   // 服务时间
};

void fcfs_scheduling(std::vector<Process>& processes) {
    std::vector<int> turnaround_times(processes.size(), 0); // 周转时间数组
    stdtatimes_t weighted_turnaround_times(processes.size(), 0); // 带权周转时间

    // 初始化起始时刻为每个进程的到达时刻
    for (int i = 0; i < processes.size(); ++i) {
        processes[i].start_time = processes[i].arrival_time;
    }

    // 遍历所有进程
    for (int i = 0; i < processes.size(); ++i) {
        // 找到当前最早到达的进程并分配CPU资源
        int current_pid = i == 0 ? processes[i].pid : -1;
        for (int j = i + 1; j < processes.size(); ++j) {
            if (processes[j].arrival_time < processes[current_pid].arrival_time) {
                current_pid = j;
            }
        }

        // 计算服务时间和周转时间
        processes[current_pid].burst_time -= processes[current_pid].start_time;
        turnaround_times[current_pid] = processes[current_pid].start_time + processes[current_pid].burst_time;

        // 更新带权周转时间（如果需要考虑优先级或等待时间）
        if (processes[current_pid].priority > 0 || processes[current_pid].waiting_time > 0) {
            weighted_turnaround_times[current_pid] = turnaround_times[current_pid] * (processes[current_pid].burst_time + processes[current_pid].priority);
        } else {
            weighted_turnaround_times[current_pid] = turnaround_times[current_pid];
        }

        // 提交服务
        processes[current_pid].finish_time = processes[current_pid].start_time + processes[current_pid].burst_time;

        // 继续下一轮循环
        if (processes[current_pid].burst_time > 0) {
            processes[current_pid].start_time = processes[current_pid].finish_time;
        }
    }

    // 输出结果
    for (int i = 0; i < processes.size(); ++i) {
        std::cout << "Process ID: " << processes[i].pid << ", Arrival Time: " << processes[i].arrival_time << ", Burst Time: " << processes[i].burst_time
                  << ", Start Time: " << processes[i].start_time << ", Finish Time: " << processes[i].finish_time
                  << ", Turnaround Time: " << turnaround_times[i] << ", Weighted Turnaround Time: " << weighted_turnaround_times[i] << std::endl;
    }
}

// 示例用法
int main() {
    std::vector<Process> processes = { {1, 0, 8}, {2, 3, 5}, {3, 4, 6} };
    fcfs_scheduling(processes);
    return 0;
}

在这个例子中，我们首先定义了一个`Process`结构体来存储进程信息，然后实现了一个`fcfs_scheduling`函数，该函数接受一个进程向量，并根据FCFS算法计算出每个进程的周转时间和带权周转时间。

请注意，这个示例假设带权周转时间的权重只考虑了进程的执行时间，如需按其他因素调整，可以根据实际情况修改`weighted_turnaround_times`的计算公式。另外，此代码未包含用户输入处理，实际应用中会需要从外部读取数据或接收命令行输入等。