要将提供的Python代码转换为C++代码，保证代码可运行

将提供的Python代码转换为C++代码需要考虑多个方面，包括类定义、成员变量、方法实现等。以下是将 `Scheduler` 和 `Timer` 类转换为C++代码的示例：

### C++ 代码

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <cassert>

// 假设 Task 类已经定义好
class Task {
public:
    int pid;
    std::string status;
    int arrival;
    int priority;
    int last_cpusc;
    int last_iosc;
    std::vector<std::pair<int, int>> pieces;

    void notify_runned(int delta) {
        // 实现任务运行时间更新逻辑
    }

    void notify_pick_to_run() {
        // 实现任务被选中运行的通知逻辑
    }

    void notify_in_wait() {
        // 实现任务进入等待队列的通知逻辑
    }
};

// 全局变量
int current_tick = 0;
const int INT32_MAX = 2147483647;
std::map<int, Task> tasks;

class Scheduler {
private:
    std::vector<int> created;
    int timer;
    std::string scheduler_type;
    int last_cpu;
    int last_io;
    int last_schedule;
    std::vector<int> cpu_queue;
    std::vector<int> io_queue;

public:
    Scheduler(int timer, const std::string& scheduler_type)
        : timer(timer), scheduler_type(scheduler_type), last_cpu(-1), last_io(-1), last_schedule(0) {}

    void create(Task task) {
        if (task.status != "exited") {
            created.push_back(task.pid);
        }
    }

    int get_next_arrival() {
        if (tasks.empty()) {
            return -1;
        }
        std::vector<int> pids;
        for (auto& kv : tasks) {
            pids.push_back(kv.first);
        }
        std::sort(pids.begin(), pids.end());
        std::vector<int> ticks;
        for (int pid : pids) {
            ticks.push_back(tasks[pid].arrival);
        }
        std::sort(ticks.begin(), ticks.end());
        for (int t : ticks) {
            if (t > current_tick) {
                return t;
            }
        }
        return -1;
    }

    void schedule() {
        int last_tick = last_schedule;
        last_schedule = current_tick;
        int delta = current_tick - last_tick;

        if (last_cpu >= 0) {
            tasks[last_cpu].notify_runned(delta);
        }
        if (last_io >= 0) {
            tasks[last_io].notify_runned(delta);
        }

        if (last_cpu >= 0 && std::find(cpu_queue.begin(), cpu_queue.end(), last_cpu) != cpu_queue.end() && tasks[last_cpu].status != "cpu") {
            cpu_queue.erase(std::remove(cpu_queue.begin(), cpu_queue.end(), last_cpu), cpu_queue.end());
        }
        if (last_io >= 0 && std::find(io_queue.begin(), io_queue.end(), last_io) != io_queue.end() && tasks[last_io].status != "io") {
            io_queue.erase(std::remove(io_queue.begin(), io_queue.end(), last_io), io_queue.end());
        }

        for (int i : created) {
            if (tasks[i].status == "exited") {
                created.erase(std::remove(created.begin(), created.end(), i), created.end());
                if (std::find(cpu_queue.begin(), cpu_queue.end(), i) != cpu_queue.end()) {
                    cpu_queue.erase(std::remove(cpu_queue.begin(), cpu_queue.end(), i), cpu_queue.end());
                }
                if (std::find(io_queue.begin(), io_queue.end(), i) != io_queue.end()) {
                    io_queue.erase(std::remove(io_queue.begin(), io_queue.end(), i), io_queue.end());
                }
                if (i == last_cpu) {
                    last_cpu = -1;
                }
                if (i == last_io) {
                    last_io = -1;
                }
            }
        }

        if (created.empty()) {
            int next_arrival = get_next_arrival();
            if (next_arrival >= 0) {
                timer.add(next_arrival, [this]() { this->schedule(); });
            }
            return;
        }

        assert(scheduler_type == "simple" || scheduler_type == "priority");
        if (scheduler_type == "simple") {
            simple_schedule();
        } else {
            priority_schedule_non_preemptive();
        }

        int cpu_timeout = INT32_MAX, io_timeout = INT32_MAX;
        if (!cpu_queue.empty()) {
            if (last_cpu == -1 || tasks[last_cpu].status != "cpu") {
                last_cpu = cpu_queue[0];
                tasks[last_cpu].notify_pick_to_run();
                cpu_timeout = std::min(tasks[last_cpu].pieces[0].second - (current_tick - tasks[last_cpu].last_cpusc), tasks[last_cpu].pieces[0].second);
            } else {
                last_cpu = -1;
            }
        }

        if (!io_queue.empty()) {
            if (last_io == -1 || tasks[last_io].status != "io") {
                last_io = io_queue[0];
                tasks[last_io].notify_pick_to_run();
                io_timeout = std::min(tasks[last_io].pieces[0].second - (current_tick - tasks[last_io].last_iosc), tasks[last_io].pieces[0].second);
            } else {
                last_io = -1;
            }
        }

        assert(cpu_timeout != INT32_MAX || io_timeout != INT32_MAX);

        int callback_timepoint = current_tick + std::min(cpu_timeout, io_timeout);
        timer.add(callback_timepoint, [this]() { this->schedule(); });
    }

    void simple_schedule() {
        for (int i : created) {
            if ((tasks[i].status == "cpu" || tasks[i].status == "cpu_wait") && std::find(cpu_queue.begin(), cpu_queue.end(), i) == cpu_queue.end()) {
                tasks[i].notify_in_wait();
                cpu_queue.push_back(i);
                assert(tasks[i].status != "cpu");
            } else if ((tasks[i].status == "io" || tasks[i].status == "io_wait") && std::find(io_queue.begin(), io_queue.end(), i) == io_queue.end()) {
                tasks[i].notify_in_wait();
                io_queue.push_back(i);
                assert(tasks[i].status != "io");
            }
        }

        if (last_cpu >= 0 && std::find(cpu_queue.begin(), cpu_queue.end(), last_cpu) != cpu_queue.end() && tasks[last_cpu].status == "cpu_wait") {
            cpu_queue.erase(std::remove(cpu_queue.begin(), cpu_queue.end(), last_cpu), cpu_queue.end());
            cpu_queue.push_back(last_cpu);
        }
        if (last_io >= 0 && std::find(io_queue.begin(), io_queue.end(), last_io) != io_queue.end() && tasks[last_io].status == "io_wait") {
            io_queue.erase(std::remove(io_queue.begin(), io_queue.end(), last_io), io_queue.end());
            io_queue.push_back(last_io);
        }

        assert(!cpu_queue.empty() || !io_queue.empty());
    }

    void priority_schedule_non_preemptive() {
        auto sort_pids_by_priority = [](const std::vector<int>& pids) -> std::vector<int> {
            std::vector<std::pair<int, int>> ret;
            for (int i : pids) {
                ret.emplace_back(i, tasks[i].priority);
            }
            std::sort(ret.begin(), ret.end(), [](const std::pair<int, int>& a, const std::pair<int, int>& b) {
                return a.second < b.second;
            });
            std::vector<int> ret2;
            for (const auto& pair : ret) {
                ret2.push_back(pair.first);
            }
            return ret2;
        };

        auto find_last_index = [](const std::vector<int>& pids, int prio) -> int {
            for (size_t index = 0; index < pids.size(); ++index) {
                if (tasks[pids[index]].priority > prio) {
                    return index;
                }
            }
            return pids.size();
        };

        for (int i : created) {
            if ((tasks[i].status == "cpu" || tasks[i].status == "cpu_wait") && std::find(cpu_queue.begin(), cpu_queue.end(), i) == cpu_queue.end()) {
                tasks[i].notify_in_wait();
                cpu_queue.push_back(i);
                assert(tasks[i].status != "cpu");
            } else if ((tasks[i].status == "io" || tasks[i].status == "io_wait") && std::find(io_queue.begin(), io_queue.end(), i) == io_queue.end()) {
                tasks[i].notify_in_wait();
                io_queue.push_back(i);
                assert(tasks[i].status != "io");
            }
        }

        cpu_queue = sort_pids_by_priority(cpu_queue);
        io_queue = sort_pids_by_priority(io_queue);

        if (last_cpu >= 0 && std::find(cpu_queue.begin(), cpu_queue.end(), last_cpu) != cpu_queue.end() && tasks[last_cpu].status == "cpu_wait") {
            cpu_queue.erase(std::remove(cpu_queue.begin(), cpu_queue.end(), last_cpu), cpu_queue.end());
            cpu_queue.insert(cpu_queue.begin() + find_last_index(cpu_queue, tasks[last_cpu].priority), last_cpu);
        }
        if (last_io >= 0 && std::find(io_queue.begin(), io_queue.end(), last_io) != io_queue.end() && tasks[last_io].status == "io_wait") {
            io_queue.erase(std::remove(io_queue.begin(), io_queue.end(), last_io), io_queue.end());
            io_queue.insert(io_queue.begin() + find_last_index(io_queue, tasks[last_io].priority), last_io);
        }

        assert(!cpu_queue.empty() || !io_queue.empty());
    }
};

class Timer {
private:
    Scheduler* scheduler;
    std::map<int, std::vector<std::function<void()>>> list;

public:
    void set_scheduler(Scheduler* scheduler) {
        this->scheduler = scheduler;
    }

    void add(int tick_expire, std::function<void()> handler) {
        if (list.find(tick_expire) == list.end()) {
            list[tick_expire] = {};
        }
        list[tick_expire].push_back(handler);

        auto it = std::find(list[tick_expire].begin(), list[tick_expire].end(), std::bind(&Scheduler::schedule, scheduler));
        if (it != list[tick_expire].end() && list[tick_expire].size() > 1) {
            std::iter_swap(it, list[tick_expire].end() - 1);
        }
    }

    void mainloop() {
        while (!list.empty()) {
            int next_tick = list.begin()->first;
            current_tick = next_tick;

            while (!list[next_tick].empty()) {
                list[next_tick].front()();
                list[next_tick].erase(list[next_tick].begin());
            }

            if (list[next_tick].empty()) {
                list.erase(next_tick);
            }
        }
    }
};

int main() {
    // 示例使用
    Timer timer;
    Scheduler scheduler(&timer, "simple");

    timer.set_scheduler(&scheduler);

    // 创建任务并添加到调度器
    Task task1{1, "cpu", 0, 1, 0, 0, {{0, 10}}};
    scheduler.create(task1);

    Task task2{2, "io", 5, 2, 0, 0, {{0, 15}}};
    scheduler.create(task2);

    // 启动定时器主循环
    timer.mainloop();

    return 0;
}

### 说明
1. **Task 类**：假设 `Task` 类已经定义好，并且实现了必要的方法和属性。
2. **Scheduler 类**：包含了创建任务、获取下一个到达时间、调度任务等方法。
3. **Timer 类**：管理定时器事件，调用调度器的方法。
4. **main 函数**：示例使用，创建任务并启动定时器主循环。

请注意，这只是一个基本的转换示例，可能需要根据具体需求进行调整和完善。特别是 `Task` 类的具体实现和其他细节部分。