C++标准库是否支持多异构有序集合按时间戳顺序迭代？

需求梳理 #

你的场景核心是：

• 多个集合，每个存储不同类型的对象，容器类型可任意（vector、deque等）
• 每个集合已按时间戳排好序，但不同类型取时间戳的方式不同（成员变量/成员函数）
• 需要按时间戳顺序遍历所有元素，对不同类型元素调用对应的处理函数

标准库原生支持情况 #

C++标准库没有直接提供完全匹配该需求的现成组件，但可以通过组合现有工具实现，比你自己写基类继承方案更灵活高效：

基于std::variant+优先队列的实现方案 #

利用std::variant封装不同类型的迭代器，结合小顶堆（优先队列）维护当前最小时间戳的元素，具体步骤如下：

1. 统一时间戳提取逻辑，为每个类型写辅助函数
2. 用std::variant存储不同容器的迭代器
3. 自定义优先队列的比较规则，按时间戳从小到大排序
4. 初始化时将每个非空集合的起始迭代器加入队列
5. 循环取出队列顶元素，调用对应类型的处理函数，再将该迭代器的下一个元素入队（未到末尾时）

示例代码：

#include <vector>
#include <deque>
#include <variant>
#include <queue>
#include <functional>
#include <iostream>

class A {
public:
    time_t timeStamp;
    int length;
};

class B {
public:
    B(time_t _tm, std::string _name) : timestamp(_tm), name(_name) {}
    time_t GetTimestamp() const { return timestamp; }
    std::string GetName() const { return name; }
private:
    time_t timestamp;
    std::string name;
};

// 统一时间戳提取接口
time_t get_timestamp(const A& a) { return a.timeStamp; }
time_t get_timestamp(const B& b) { return b.GetTimestamp(); }

// 包装迭代器变体，用于优先队列
struct IteratorWrapper {
    using IterVariant = std::variant<std::vector<A>::const_iterator, std::deque<B>::const_iterator>;
    IterVariant current;
    IterVariant end;

    // 获取当前元素的时间戳
    time_t get_ts() const {
        return std::visit([](const auto& iter) { return get_timestamp(*iter); }, current);
    }

    // 判断是否遍历到末尾
    bool is_done() const {
        return std::visit([](const auto& curr, const auto& e) { return curr == e; }, current, end);
    }

    // 迭代器自增
    void next() {
        std::visit([](auto& iter) { ++iter; }, current);
    }

    // 调用对应类型的处理函数
    void handle(const std::function<void(const A&)>& a_func, const std::function<void(const B&)>& b_func) const {
        std::visit([&](const auto& iter) {
            using T = std::decay_t<decltype(*iter)>;
            if constexpr (std::is_same_v<T, A>) {
                a_func(*iter);
            } else if constexpr (std::is_same_v<T, B>) {
                b_func(*iter);
            }
        }, current);
    }
};

// 优先队列比较规则：小顶堆，时间戳小的在前
struct CompareWrapper {
    bool operator()(const IteratorWrapper& lhs, const IteratorWrapper& rhs) {
        return lhs.get_ts() > rhs.get_ts();
    }
};

int main() {
    std::vector<A> listA = {{1, 4}, {5, 7}, {8, 9}};
    std::deque<B> listB = {B(0, "bob"), B(3, "Frank")};

    std::priority_queue<IteratorWrapper, std::vector<IteratorWrapper>, CompareWrapper> pq;

    // 初始化队列
    if (!listA.empty()) pq.push({listA.begin(), listA.end()});
    if (!listB.empty()) pq.push({listB.begin(), listB.end()});

    // 定义各类型的处理逻辑
    auto a_handler = [](const A& a) { std::cout << a.length << std::endl; };
    auto b_handler = [](const B& b) { std::cout << b.GetName() << std::endl; };

    // 按时间戳顺序遍历处理
    while (!pq.empty()) {
        auto top = pq.top();
        pq.pop();

        top.handle(a_handler, b_handler);
        top.next();
        if (!top.is_done()) pq.push(top);
    }

    return 0;
}

和你自行实现的基类方案对比 #

• 基类方案依赖虚函数，有运行时开销；而std::variant方案通过编译期分支处理，性能更优
• 基类需要为每个类型写派生类，扩展性差；std::variant新增类型只需扩展迭代器变体和处理分支即可

总结 #

C++标准库没有直接的现成组件，但通过组合std::variant、std::priority_queue和std::visit，可以更简洁灵活地实现你的需求，避免手写继承体系的冗余。

内容的提问来源于stack exchange，提问作者bpeikes