在 c++17 中过滤类型的元组

Question

std::tuple a{1,3,4,5} -> 使其成为大于 3 的数字

std::tuple b{4,5}    

或者

std::tuple a{
    std::integral_constant<int,1> {},
    std::integral_constant<int,3> {},
    std::integral_constant<int,4> {},
    std::integral_constant<int,5> {} 
}

到

std::tuple a{
    std::integral_constant<int,4>{},
    std::integral_constant<int,5>{}
};

如何在编译时转换它？我可以使用integer_sequence 来做到这一点，但这很麻烦。在 C++17 中是否有更简单的方法使用折叠表达式或std::apply

同样经过过滤，还需要得到一个唯一条目的元组。但我的假设是，如果可以进行过滤，那么找到唯一性将是微不足道的。

编辑以便更清楚： std::tuple<int_c<1>, int_c<3>,int_c<4>,int_c<5>> to std::tuple<int_c<4>,int_c<5>

编辑： 我在摆弄，也许这样的东西会起作用：

以template... C 作为积分常量列表：

constexpr auto result = std::tuple_cat(std::conditional_t<(C::value > 3), std::tuple<C>, std::tuple<>>{}...);

Answer 1

您可以使用 C++17 中的新 STL 实用程序来做到这一点。应该是这样的：

template<typename T>
auto filter(T tup) {
    return std::apply([&](auto first, auto... rest) {
        auto filtered_rest = [&]{
            if constexpr (sizeof...(rest)) {
                return filter(std::tuple{rest...});
            } else {
                return std::tuple{};
            }
        }();

        if constexpr (first > 3) {
            return std::tuple_cat(std::tuple{first}, filtered_rest);
        } else {
            return filtered_rest;
        }
    }, tup);
}

当然，还有很多其他方法可以做到这一点。在这种情况下，我使用了std::apply 和递归。我从一个空元组开始，一次添加一个元素。

现场示例：https://godbolt.org/z/qo63r4

Answer 2

用 c++17 生成你的tuple_cat：

constexpr auto result = std::apply([](auto...ts) {
    return std::tuple_cat(std::conditional_t<(decltype(ts)::value > 3),
                          std::tuple<decltype(ts)>,
                          std::tuple<>>{}...);
}, tup);

Answer 3

一种可能的解决方案是生成一个特征，该特征将为所需元素输出std::tuple<T>，为不需要的元素输出std::tuple<>，并使用std::tuple_cat 将这些元组重新组合成一个类型。例如：

#include <tuple>
#include <type_traits>
#include <utility>

template <typename Pred, typename Tuple> struct filter;

template <typename t_Predicate, typename ...Ts> 
struct filter<t_Predicate, std::tuple<Ts...>>
{
    // If this element has to be kept, returns `std::tuple<Ts>`
    // Otherwise returns `std::tuple<>`
    template<class E>
    using t_filter_impl = std::conditional_t<
        t_Predicate<E>::value,
        std::tuple<E>, std::tuple<>>;

    // Determines the type that would be returned by `std::tuple_cat`
    //  if it were called with instances of the types reported by 
    //  t_filter_impl for each element
    using type = decltype(std::tuple_cat(std::declval<t_filter_impl<Ts>>()...));
};

其中t_Predicate<T> 是任何具有bool value; 成员的谓词类型，该成员确定T 是否是理想类型。例如，将此解决方案应用于原始问题，首先编写一个专门用于std::integral_constant 的谓词类型：

// Non integral_constant are not kept
template<class T>
struct four_or_more : std::integral_constant<bool, false> {};

// integral_const types are kept if their value is >=4
template<class T, T V>
struct four_or_more<std::integral_constant<T, V>> :
    std::integral_constant<bool, V >= 4> {};

这是一个演示：

#include <iostream>

int main()
{
    auto a = std::make_tuple(
        std::integral_constant<int,1> {},
        std::integral_constant<int,3> {},
        std::integral_constant<int,4> {},
        std::integral_constant<int,5> {}
    );

    using b_type = filter<four_or_more, decltype(a)>::type;

    std::cout << "size : " << std::tuple_size<b_type>() << std::endl;
    std::cout << std::tuple_element_t<0, b_type>::value << std::endl;
    std::cout << std::tuple_element_t<1, b_type>::value << std::endl;
}