使用C++按照时间片轮转法写一个程序，使用的基本思想是：将CPU 的处理时间划分成一个个时间片，就绪队列中的诸进程轮流运行一个时间片，当时间片结束时，就强迫运行进程让出CPU，该进程进入就绪队列，等待下一次调度，同时,进程调度又去选择就绪队列中的一个进程,分配给它一个时间片，以投入运行。在轮转法中，时间片长度的选择非常重要,将直接影响系统开销和响应时间。如果时间片长度很小，则调度程序剥夺处理机的次数频繁,加重系统开销；反之，如果时间片长度选择过长，比方说一个时间片就能保证就绪队列中所有进程都执行完毕，则轮转法就退化成先进先出算法。

好的，我可以给你一个使用时间片轮转法的简单C++程序示例，代码如下：

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

struct Process {
    int pid;    // 进程ID
    int time;   // 进程需要的执行时间
};

void RoundRobin(int n, int time_slice, Process p[]) {
    queue<Process> ready_queue;     // 就绪队列
    int cur_time = 0;               // 当前时间
    int cur_pid = -1;               // 当前正在执行的进程ID
    int remain_time = 0;            // 当前正在执行的进程剩余执行时间
    
    while (!ready_queue.empty() || cur_pid != -1) {    // 只要就绪队列不为空或者当前有进程在执行
        // 将所有到达时间小于等于当前时间的进程加入就绪队列
        for (int i = 0; i < n; i++) {
            if (p[i].time > 0 && p[i].time <= cur_time) {
                ready_queue.push(p[i]);
                p[i].time = 0;
            }
        }
        
        // 如果当前没有正在执行的进程，则从就绪队列中取出一个进程
        if (cur_pid == -1 && !ready_queue.empty()) {
            Process next_process = ready_queue.front();
            ready_queue.pop();
            cur_pid = next_process.pid;
            remain_time = next_process.time > time_slice ? time_slice : next_process.time;
        }
        
        // 执行当前进程
        remain_time--;
        cur_time++;
        if (remain_time == 0) {
            cur_pid = -1;
        }
    }
}

int main() {
    int n;              // 进程数
    int time_slice;     // 时间片长度
    Process p[100];     // 进程数组
    
    // 输入进程数、时间片长度和每个进程需要的执行时间
    cout << "请输入进程数和时间片长度：";
    cin >> n >> time_slice;
    cout << "请输入每个进程需要的执行时间：" << endl;
    for (int i = 0; i < n; i++) {
        cout << "进程" << i << "的执行时间：";
        cin >> p[i].time;
        p[i].pid = i;
    }
    
    // 执行时间片轮转调度算法
    RoundRobin(n, time_slice, p);
    
    return 0;
}

这个程序可以让你输入进程数、时间片长度和每个进程需要的执行时间，然后使用时间片轮转法进行调度，并输出每个进程的执行顺序。需要注意的是，这个程序没有考虑进程的优先级等因素，只是一个简单的示例，你可以根据实际需求进行改进。