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），并且我们希望有一个访问者返回不同类型的对象（在这种情况下，迭代器将访问基础容器的开头）。但是，这显然不会编译，因为std::vector<int>::iterator与std::vector<double>::iterator不同。是否有可能通过额外的间接层实质上实现此目的的整洁方法？

Answer 1

您可以返回其他变体

#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和变体，您可以获得适当的返回类型。

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 2

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

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);

我可以想象通过自动推导正确的变量返回类型来完成此操作，但这需要大量的编码。

Answer 3

以@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同时也添加了常规解决方案。

Answer 4

我认为您需要做些不同的事情，在当前情况下，迭代器有所不同，但是您可以绕开它：

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

基本上是同一件事。

具有不同返回类型的访客

4 个答案: