如何为C++类传入可变数量类型以维护多类型队列集合？

核心思路是用std::tuple存储异构类型的std::queue，结合可变参数模板在编译期保留类型信息，既满足动态创建不同类型队列的需求，又能严格校验存取操作的类型一致性，完全规避std::any带来的类型安全问题。

完整实现代码 #

#include <tuple>
#include <queue>
#include <stdexcept>
#include <type_traits>
#include <utility>

template<typename... Ts>
class C {
private:
    std::tuple<std::queue<Ts>...> queues_;

    // 编译期校验索引合法性
    template<std::size_t Index>
    void validate_index() const {
        if constexpr (Index >= sizeof...(Ts)) {
            throw std::out_of_range("Queue index exceeds available queues");
        }
    }

public:
    // 默认构造函数自动初始化所有队列
    C() = default;

    // 向指定索引队列存入数据，强制类型匹配
    template<std::size_t Index, typename T>
    void push(T&& value) {
        validate_index<Index>();
        // 静态断言确保传入类型与队列元素类型一致
        using QueueType = std::tuple_element_t<Index, decltype(queues_)>;
        static_assert(std::is_same_v<std::decay_t<T>, typename QueueType::value_type>,
                      "Value type does not match the target queue's element type");
        
        std::get<Index>(queues_).push(std::forward<T>(value));
    }

    // 获取指定索引队列的队首元素
    template<std::size_t Index>
    auto front() const {
        validate_index<Index>();
        return std::get<Index>(queues_).front();
    }

    // 弹出指定索引队列的队首元素
    template<std::size_t Index>
    void pop() {
        validate_index<Index>();
        std::get<Index>(queues_).pop();
    }

    // 检查指定索引队列是否为空
    template<std::size_t Index>
    bool empty() const {
        validate_index<Index>();
        return std::get<Index>(queues_).empty();
    }
};

关键特性说明 #

1. 异构类型存储：类模板参数Ts...直接映射到std::tuple的元素类型，比如C<int, double, double, int>会生成包含std::queue<int>, std::queue<double>, std::queue<double>, std::queue<int>的tuple，完全匹配需求中的可变类型列表。
2. 编译期类型校验：push方法中的static_assert会在编译期检查传入值的类型与目标队列的元素类型是否一致，一旦类型不匹配直接触发编译错误，彻底避免运行期类型错误。
3. 编译期索引校验：validate_index函数用constexpr在编译期判断索引是否越界，合法索引直接通过，越界索引在编译阶段就会报错（如果是常量索引），运行期也会抛出异常兜底。
4. 无递归实现：借助C++11及以后的可变参数模板和std::tuple的原生支持，不需要手动编写递归代码来展开参数包，代码简洁易维护。

使用示例 #

#include <iostream>

int main() {
    // 初始化包含int、double、double、int四种队列的集合
    C<int, double, double, int> queue_collection;

    // 向对应索引的队列存入数据
    queue_collection.push<0>(10);
    queue_collection.push<1>(3.14);
    queue_collection.push<2>(2.718);
    queue_collection.push<3>(100);

    // 读取并打印队首元素
    std::cout << "Queue 0 front: " << queue_collection.front<0>() << std::endl;
    std::cout << "Queue 1 front: " << queue_collection.front<1>() << std::endl;

    // 弹出元素并检查队列状态
    queue_collection.pop<0>();
    std::cout << "Queue 0 is empty? " << std::boolalpha << queue_collection.empty<0>() << std::endl;

    // 以下操作会触发编译错误，符合预期
    // queue_collection.push<0>(3.14); // 类型不匹配
    // queue_collection.push<4>(50);    // 索引越界
}

优势总结 #

• 类型安全：所有类型校验和索引检查在编译期完成，彻底杜绝类型不匹配、索引越界等运行时错误。
• 性能高效：没有额外的类型转换或运行时类型判断开销，操作效率与直接使用单个std::queue一致。
• 扩展性强：支持任意合法类型的队列（包括自定义类型、指针等），只需在类实例化时传入对应类型即可。

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