如何使用可变参数模板进行 std::variant 和 std::visit？

Question

我正在尝试使用命令和工厂模式编写逻辑。基于 std::variant 中的数据，我想创建一个对象。它可能看起来像 C++ 类型的映射。

代码如下：Wandbox

我可以对所有使用的类型进行硬编码，但我想使用可变参数模板使其自动化，该怎么做？

#include <cassert>
#include <variant>
#include <type_traits>
#include <memory>
#include <iostream>


struct IFace
{
    virtual void foo() = 0;
};

template<typename TKey, typename TValue>
struct Base : IFace
{
    using Key = TKey;
    using Value = TValue;
};

struct Int : Base<int, Int>
{
    void foo() override { std::cout << "Int"; }
};

struct Double : Base<double, Double>
{
    void foo() override { std::cout << "Double"; }
};

using Var = std::variant<int, double>;

template<typename ...Args>
std::shared_ptr<IFace> factory(const Var& v)
{
    std::shared_ptr<IFace> p;

    std::visit([&p](auto&& arg){
        using TKey = std::decay_t<decltype(arg)>;
        // TODO: use variadic instead of hardcoded types
        if constexpr (std::is_same_v<TKey, int>)
        {
            using TValue = typename Base<TKey, Int>::Value;
            p = std::make_shared<TValue>();
            std::cout << "int ";
        }
        else if constexpr (std::is_same_v<TKey, double>)
        {
            using TValue = typename Base<TKey, Double>::Value;
            p = std::make_shared<TValue>();
            std::cout << "double ";
        }
    }, v);

    return p;
}


int main()
{
    const Var v = 42;
    auto p = factory<Int, Double>(v);

    assert(p != nullptr);
    p->foo();

    return 0;
}

Answer 1

这个流行的小“重载”class 对于将 lambda 传递给 std::visit 总是很有用：

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

然后，不要使用通用的 lambda 并尝试从参数类型中推断出正确的对象类型，只需为每个 Args.

生成一个重载

template<typename ...Args>
std::shared_ptr<IFace> factory(const std::variant<typename Args::Key...>& v)
{
    return std::visit(overloaded { 
        [](const typename Args::Key&) -> std::shared_ptr<IFace> { return std::make_shared<Args>(); }... 
    }, v);
}

演示：https://godbolt.org/z/nKGf3c

如何使用可变参数模板进行 std::variant 和 std::visit？

How to use variadic templates to proceed std::variant with std::visit?

c++

variadic-templates