具有不同 return 类型的变体访问者

Question

考虑以下使用 boost::variant 的代码（但也应该完全适用于 std::variant）。

#include <vector>
#include <boost/variant.hpp>

int main()
{
    boost::variant<std::vector<int>, std::vector<double> > vr 
        = std::vector<int>(5, 5);;

    // OK, no problem.
    boost::apply_visitor([](auto a) { std::cout << a[0] << "\n"; }, vr);

    // ERROR: return types must not differ.
    //boost::apply_visitor([](auto a) { return a.begin(); }, vr);
}

在这里，我们有一个变体可以吃掉不同类型的标准向量（例如，本例中的 int 和 double），我们希望有一个访问者 returns 不同类型的对象（在本例中，迭代器指向底层容器的开头）。但是，这不会编译，因为显然 std::vector<int>::iterator 与 std::vector<double>::iterator 不同。有没有一种从根本上实现这一目标的巧妙方法，可能是通过一个额外的间接层？

Answer 1

我认为你需要做不同的事情，迭代器在你当前的情况下是不同的，但你可以绕过它：

std::vector<boost::variant<int, double>> vr = std::vector<int>(5, 5);

基本上是一样的

Answer 2

您可以return一个不同的变体

#include <iostream>
#include <vector>
#include <boost/variant.hpp>

int main()
{
    boost::variant<std::vector<int>, std::vector<double> > vr 
        = std::vector<int>(5, 5);
    using iter_variant = boost::variant<std::vector<int>::iterator, std::vector<double>::iterator >;

    using value_variant = boost::variant<int, double>;

    // OK, no problem.
    boost::apply_visitor([](auto a) { std::cout << a[0] << "\n"; }, vr);

    // Also OK
    boost::apply_visitor([](auto a) -> iter_variant { return a.begin(); }, vr);

    // Also OK
    boost::apply_visitor([](auto a) -> value_variant { return a[0]; }, vr);
}

See it live

给定一个通用的 lambda 和一个变体，您可以获得合适的 return 类型。

template<typename Func, typename Variant>
struct visitor_result;

template<typename Func, typename ... Ts>
struct visitor_result<Func, boost::variant<Ts...>>
{
    using type = boost::variant<decltype(std::declval<Func>()(std::declval<Ts>()))...>;
};

template<typename Func, typename Variant>
using visitor_result_t = typename visitor_result<Func, Variant>::type;

template<typename Func, typename Variant>
visitor_result_t<Func, Variant> generic_visit(Func func, Variant variant)
{
    return boost::apply_visitor([&](auto a) -> visitor_result_t<Func, Variant> { return func(a); }, variant);
}

See it live

Answer 3

也使用变体结果类型。换句话说：

boost::variant<std::vector<int>, std::vector<double> > vr 
    = std::vector<int>(5, 5);;

boost::apply_visitor([](auto a) -> boost::variant<int, double> {
    using T = std::decay_t<decltype(a)>;
    if constexpr (std::is_same_v<T, std::vector<int>>) {
         int v = 0;
         for(auto q : a) v += q;
         return v;
    }
    else if constexpr (std::is_same_v<T, std::vector<double>>) {
         double v = 0;
         for(auto q : a) v += q;
         return v;
    }
}, vr);

我可以想象通过自动推导正确的变体 return 类型来完成这项工作，但这需要大量编码。

Answer 4

基于@Caleth 的回答，这允许在不复制参数列表的情况下使用任何变体。

#include <vector>
#include <variant>
#include <type_traits>

//Replace with more appropriate name
template<typename Variant, typename Lambda>
struct X_impl;
template<typename...Ts, typename Lambda>
struct X_impl<std::variant<Ts...>, Lambda>{
    using type = std::variant<std::invoke_result_t<Lambda,Ts>...>;
};
template<typename...Ts, typename Lambda>
struct X_impl<const std::variant<Ts...>, Lambda>{
    using type = std::variant<std::invoke_result_t<Lambda,const Ts>...>;
};

template<typename Variant, typename Lambda>
using X = typename X_impl<std::remove_reference_t<Variant>, Lambda>::type;


template<typename Variant, typename Lambda>
auto visit(Variant&& variant, Lambda&& lambda){
    auto wrapped_lambda = [&lambda](auto&& arg) -> X<Variant,Lambda>{ 
        using T = decltype(arg);
        return std::forward<Lambda>(lambda)(std::forward<T>(arg));
    };
    return std::visit(wrapped_lambda, std::forward<Variant>(variant));
}
int main()
{
    std::variant<std::vector<int>,const std::vector<double> > vr = std::vector<int>(5, 5);
    const std::variant<std::vector<int>,const std::vector<double> > c_vr = std::vector<int>(5, 5);
    auto& ref_vr = vr;
    auto& ref_c_vr = c_vr;

    auto visit_fnc = [](auto&& a){return a.begin();};
    visit(vr, visit_fnc);
    visit(c_vr, visit_fnc);
    visit(ref_vr, visit_fnc);
    visit(ref_c_vr, visit_fnc);
}

编辑：哦，看起来@Caleth同时也添加了通用解决方案。

具有不同 return 类型的变体访问者

Variant visitor with different return types

c++

variant

boost-variant