到达时间，进程优先数，运行时间人为指定，进程的优先数及所需的运行时间可以事先人为指定（也可以由随机数产生），如果运行一个时间片（1s）后，进程已占用CPU时间达到所需的运行时间则撤销该进程，如果运行一个时间片之后进程已占用CPU时间片的时间未达到所需要的运行时间，即进程需要继续运行，此时将进程的优先数-1，然后将其插入就绪队列等待CPU，这C++最高优先数优先算法怎么写

好的，根据你的要求，这里给出一个简单的C++实现，使用的是最高优先权优先算法（Highest Priority First，HPF）：

#include <iostream>
#include <queue>
#include <ctime>

using namespace std;

// 进程结构体
struct process {
    int id;             // 进程ID
    int arrival_time;   // 到达时间
    int priority;       // 优先数
    int remaining_time; // 剩余运行时间
};

// 重载运算符，用于优先队列中的排序
struct cmp {
    bool operator() (const process& p1, const process& p2) {
        return p1.priority < p2.priority;
    }
};

int main() {
    // 随机生成10个进程
    srand(time(NULL));
    vector<process> processes;
    for (int i = 0; i < 10; i++) {
        process p;
        p.id = i;
        p.arrival_time = rand() % 10;
        p.priority = rand() % 10;
        p.remaining_time = rand() % 10 + 1;
        processes.push_back(p);
    }

    // 按到达时间排序
    sort(processes.begin(), processes.end(), [](process& p1, process& p2) {
        return p1.arrival_time < p2.arrival_time;
    });

    // 优先队列，存储就绪进程
    priority_queue<process, vector<process>, cmp> ready_queue;

    // 记录当前时间片
    int current_time = 0;

    // 循环直到所有进程结束
    while (!processes.empty() || !ready_queue.empty()) {
        // 将到达时间小于等于当前时间的进程加入就绪队列
        while (!processes.empty() && processes.back().arrival_time <= current_time) {
            ready_queue.push(processes.back());
            processes.pop_back();
        }

        // 如果就绪队列不为空，取出优先级最高的进程运行一个时间片
        if (!ready_queue.empty()) {
            process p = ready_queue.top();
            ready_queue.pop();
            cout << "时间片 " << current_time << " 运行进程 " << p.id << endl;
            p.remaining_time--;
            if (p.remaining_time == 0) {
                cout << "进程 " << p.id << " 运行结束" << endl;
            } else {
                p.priority--;
                ready_queue.push(p);
            }
        }

        // 时间片加一
        current_time++;
    }

    return 0;
}

在这个实现中，我们首先随机生成了10个进程，并按到达时间排序。然后使用了一个优先队列 `ready_queue` 来存储就绪进程，使用了一个重载的运算符来进行优先级比较。在每个时间片中，我们将到达时间小于等于当前时间的进程加入就绪队列，然后取出优先级最高的进程运行一个时间片。如果进程运行结束，输出进程ID并从队列中删除；否则，将其优先级减一并重新加入队列。

注意，这个实现中没有考虑进程的阻塞等情况，也没有考虑多核CPU。如果需要考虑这些因素，需要对算法进行相应的修改。