c++ - 仅当元组中存在该类型时才将函数应用于元组元素

Question

我想要实现的目标如下，连同我现在的位置:

template <typename Fn, typename Tuple, size_t... Is>
auto apply_if_impl(Tuple t, Fn&& f, std::index_sequence<Is...>) {
    return std::make_tuple(
        std::is_same_v<std::string, std::tuple_element_t<Is, Tuple>> ? 
        f(std::get<Is>(t)) : 
        std::get<Is>(t)...
    );
}

template <typename Fn, typename ...Ts>
auto apply_if(std::tuple<Ts...> t, Fn&& f) {
    return apply_if_impl(t, f, std::make_index_sequence<sizeof...(Ts)>());
}

并以如下方式实现，例如:

int main() {
    std::tuple<int, std::string, float> t{42, "hello", 3.14f};

    // this one should return 
    // std::tuple<int, std::size_t, float>{42, 5, 3.14f};
    apply_if(t, [](std::string s){ return s.size(); });

    // return value of this should be equal to t above since
    // there is no vector element in the given tuple
    apply_if(t, [](std::vector<int> s){ return s.size(); });
}

将返回另一个 std::tuple但是一个std::tuple<int, std::size_t, float>元素 42 和 5(长度为 "hello")和 3.14。如果给定的元组中没有元素可以应用给定的可调用对象，则只返回给定的元组而不做任何事情。因此，给定 std::tuple<int, std::string, float> 的拷贝在后一种情况下将被退回或移动，无论如何。

我遇到的问题是，在我的三元语句中，编译器仍然看到该函数被应用于元组中的其他成员。我该如何解决这个问题？我需要一个编译时三元的东西来扩展 make_tuple正确调用。最后，我需要摆脱那个硬编码的 std::string以及。我需要在那里输入可调用的参数类型。

编辑:不要犹豫，使用像 boost::hana 这样的库如果他们想让解决方案更容易。对我来说也是一个很好的锻炼。

Answer 1

你可以通过另一个中间模板:

template <bool>
class Select
{
public:
    template <typename F, typename T>
    T& operator()(F&, T& t) const
    {
        return t;
    }
};

template <>
class Select<true>
{
public:
    template <typename F, typename T>
    auto operator()(F& f, T& t) const -> decltype(f(t))
    {
        return f(t);
    }
};

template<typename Fn, typename Tuple, size_t ... Is>
auto apply_if_impl(Tuple t, Fn&& f, std::index_sequence<Is...>)
{
    return std::make_tuple
            (
                    Select<std::is_same_v<std::string, std::tuple_element_t<Is, Tuple>>>()
                           (f, std::get<Is>(t))...
            );
}