我现在正在进行操作系统大作业，请用c++实现SJF抢占式调度算法，要求：1）输入各进程到达时间（以空格间隔）和运行时间（以空格间隔），手动输入。 2）结果输出各进程的开始时间和结束时间、进程的平均等待时间，和具体的甘特图。

好的，以下是基于C++的SJF抢占式调度算法的实现代码：

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

using namespace std;

struct Process {
    int id; // 进程 ID
    int arrival_time; // 到达时间
    int run_time; // 运行时间
    int start_time; // 开始时间
    int end_time; // 结束时间
    int wait_time; // 等待时间
    Process(int id, int arrival_time, int run_time) :
        id(id), arrival_time(arrival_time), run_time(run_time),
        start_time(0), end_time(0), wait_time(0) {}
};

// 按到达时间排序的小根堆
struct CompareArrivalTime {
    bool operator() (const Process &a, const Process &b) {
        return a.arrival_time > b.arrival_time;
    }
};

// 按剩余运行时间排序的小根堆
struct CompareRunTime {
    bool operator() (const Process &a, const Process &b) {
        return a.run_time > b.run_time;
    }
};

void sjf(vector<Process> &processes) {
    int cur_time = 0; // 当前时间
    int n = processes.size(); // 进程数
    int total_wait_time = 0; // 总等待时间

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

    priority_queue<Process, vector<Process>, CompareRunTime> pq;

    // 遍历所有进程
    for (int i = 0, j = 0; i < n || !pq.empty(); ) {
        // 将所有到达时间小于等于当前时间的进程加入小根堆
        while (i < n && processes[i].arrival_time <= cur_time) {
            pq.push(processes[i]);
            i++;
        }

        if (pq.empty()) {
            // 当前没有进程在运行
            cur_time = processes[i].arrival_time;
            continue;
        }

        // 取出剩余时间最短的进程进行运行
        Process p = pq.top();
        pq.pop();

        // 计算等待时间
        p.wait_time = cur_time - p.arrival_time;
        total_wait_time += p.wait_time;

        // 计算开始时间和结束时间
        p.start_time = cur_time;
        p.end_time = cur_time + p.run_time;

        // 更新当前时间
        cur_time = p.end_time;

        // 将当前进程重新加入小根堆
        while (j < n && processes[j].arrival_time <= cur_time) {
            pq.push(processes[j]);
            j++;
        }

        // 如果当前进程还有剩余时间，则重新加入小根堆
        if (p.run_time > 0) {
            pq.push(p);
        }
    }

    // 计算平均等待时间
    double avg_wait_time = (double)total_wait_time / n;

    // 输出结果
    cout << "进程\t开始时间\t结束时间\t等待时间" << endl;
    for (int i = 0; i < n; i++) {
        cout << processes[i].id << "\t"
            << processes[i].start_time << "\t\t"
            << processes[i].end_time << "\t\t"
            << processes[i].wait_time << endl;
    }

    // 输出甘特图
    cout << endl << "甘特图：" << endl;
    for (int i = 0; i < n; i++) {
        cout << "P" << processes[i].id << "\t";
        for (int j = 0; j < processes[i].run_time; j++) {
            cout << "*";
        }
        cout << endl;
    }

    // 输出平均等待时间
    cout << endl << "平均等待时间：" << avg_wait_time << endl;
}

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

    vector<Process> processes;
    for (int i = 0; i < n; i++) {
        int arrival_time, run_time;
        cout << "请输入第 " << i+1 << " 个进程的到达时间和运行时间（以空格间隔）：";
        cin >> arrival_time >> run_time;
        processes.emplace_back(i+1, arrival_time, run_time);
    }

    sjf(processes);

    return 0;
}

注：该程序在 Windows 系统下使用 Visual Studio 2019 编译通过。在其他系统下可能需要做相应的调整。