用C++语言实现操作系统实验：分别用非抢占式静态优先权调度策略，时间片轮转调度策略实现，写出代码并执行。

由于操作系统是一个非常复杂的系统，我们无法在这里完整地给出一个操作系统的实现代码。但是，我们可以给出一个简单的示例程序，它演示了如何使用非抢占式静态优先权调度策略和时间片轮转调度策略来实现一个简单的多任务操作系统。

下面是一个使用C++语言实现的简单的多任务操作系统的示例程序：

#include <iostream>
#include <vector>

using namespace std;

// 进程结构体
struct Process {
    int pid; // 进程ID
    int priority; // 进程优先级
    int burst_time; // 进程运行时间
    int remaining_time; // 进程剩余运行时间
};

// 非抢占式静态优先权调度策略
void non_preemptive_priority_scheduling(vector<Process>& processes) {
    int n = processes.size();

    // 对进程按照优先级进行排序
    sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.priority < b.priority;
    });

    // 执行进程
    for (int i = 0; i < n; i++) {
        Process& p = processes[i];
        cout << "Running process #" << p.pid << endl;
        for (int j = 0; j < p.burst_time; j++) {
            p.remaining_time--;
            cout << "Process #" << p.pid << " is running (" << p.remaining_time << "s remaining)" << endl;
        }
    }
}

// 时间片轮转调度策略
void round_robin_scheduling(vector<Process>& processes, int time_slice) {
    int n = processes.size();

    // 执行进程
    int i = 0;
    while (true) {
        Process& p = processes[i];
        cout << "Running process #" << p.pid << endl;
        for (int j = 0; j < time_slice; j++) {
            if (p.remaining_time == 0) {
                break;
            }
            p.remaining_time--;
            cout << "Process #" << p.pid << " is running (" << p.remaining_time << "s remaining)" << endl;
        }
        if (p.remaining_time == 0) {
            i++;
        }
        if (i == n) {
            i = 0;
        }
        if (all_of(processes.begin(), processes.end(), [](const Process& p) {
            return p.remaining_time == 0;
        })) {
            break;
        }
    }
}

int main() {
    // 创建进程
    vector<Process> processes = {
        {1, 2, 5, 5},
        {2, 1, 4, 4},
        {3, 3, 2, 2},
        {4, 4, 1, 1}
    };

    // 非抢占式静态优先权调度策略
    cout << "Non-preemptive priority scheduling:" << endl;
    non_preemptive_priority_scheduling(processes);

    // 时间片轮转调度策略
    cout << "Round-robin scheduling:" << endl;
    round_robin_scheduling(processes, 2);

    return 0;
}

在上面的示例程序中，我们定义了一个`Process`结构体来表示进程。`Process`结构体包含`pid`（进程ID）、`priority`（进程优先级）、`burst_time`（进程运行时间）和`remaining_time`（进程剩余运行时间）等成员变量。

我们还定义了两个函数`non_preemptive_priority_scheduling`和`round_robin_scheduling`，分别对应非抢占式静态优先权调度策略和时间片轮转调度策略。这两个函数都接受一个指向进程数组的指针，并按照不同的调度策略执行这些进程。

在`non_preemptive_priority_scheduling`函数中，我们首先对进程按照优先级进行排序，然后依次执行这些进程。在执行进程时，我们使用一个简单的循环来模拟进程的运行，每次循环中让进程的`remaining_time`减1，并输出一条运行信息。

在`round_robin_scheduling`函数中，我们采用时间片轮转调度策略来执行进程。具体来说，我们使用一个循环来依次执行每个进程。每个进程执行一个时间片（即`time_slice`），然后切换到下一个进程。当所有进程都执行完毕时，循环结束。

最后，在`main`函数中，我们创建了一个包含4个进程的进程数组。我们首先使用非抢占式静态优先权调度策略来执行这些进程，然后使用时间片轮转调度策略来执行这些进程。在执行每个进程时，我们输出一些信息，以便观察调度过程。

注意：上面的示例程序只是一个简单的示例，它并不能完整地演示操作系统的实现过程。如果你想深入学习操作系统，建议阅读相关的教材和资料，以了解更多的内容。