C++可变参数模板实战：从递归解析到参数归一化存储

1次阅读

共计 1993 个字符，预计需要花费 5 分钟才能阅读完成。

在 C ++ 开发中，处理可变参数时总会遇到几个头疼的问题：类型安全无法保证、参数存储困难、运行时访问复杂。传统方法如 va_list 虽然能处理可变参数，但完全丧失了类型信息，调试时经常遇到诡异的崩溃问题。而现代 C ++ 的可变参数模板虽然提供了类型安全，但如何存储和访问这些异构参数又成了新的挑战。

完全类型不安全，编译期无法检查参数类型
需要手动管理参数栈，容易导致内存越界
无法直接用于面向对象的场景

编译期展开参数包，保证类型安全
通过 SFINAE 约束参数类型
天然支持现代 C ++ 类型系统

使用 std::variant 或自定义类型擦除
统一存储到std::vector<Object>
提供类型安全的访问接口

template<typename... Args>
void processArgs(Args&&... args) {
    // 递归终止条件
    if constexpr (sizeof...(Args) == 0) {return;}
    else {
        // 处理第一个参数
        processSingleArg(std::get<0>(std::forward_as_tuple(args...)));

        // 递归处理剩余参数
        if constexpr (sizeof...(Args) > 1) {processArgs(std::get<1>(std::forward_as_tuple(args...))...);
        }
    }
}

定义统一的存储类型：

class Object {
public:
    template<typename T>
    Object(T&& value) : 
        data_(std::make_shared<Holder<T>>(std::forward<T>(value))) {}

    template<typename T>
    T get() const {if (auto p = dynamic_cast<Holder<T>*>(data_.get())) {return p->value_;}
        throw std::bad_cast();}

private:
    struct BaseHolder {virtual ~BaseHolder() = default;
    };

    template<typename T>
    struct Holder : BaseHolder {
        T value_;
        Holder(T&& value) : value_(std::forward<T>(value)) {}};

    std::shared_ptr<BaseHolder> data_;
};

使用示例：

std::vector<Object> storeArgs(auto&&... args) {
    std::vector<Object> result;
    (result.emplace_back(std::forward<decltype(args)>(args)), ...);
    return result;
}

template<typename... Visitors>
void visitObject(const Object& obj, Visitors&&... visitors) {auto visitHelper = [&obj](auto&& visitor) {using T = std::decay_t<decltype(visitor)>;
        if constexpr (std::is_invocable_v<T, int>) {try { visitor(obj.get<int>()); } catch(...) {}}
        // 其他类型处理...
    };

    (visitHelper(std::forward<Visitors>(visitors)), ...);
}