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> <-如果在没有额外声明函数的情况下，以简洁的c ++ 17方式实现上述目的，那就可以了！。

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

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

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

Answer 1

使用c ++ 17制作tuple_cat：

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

Answer 2

一种可能的解决方案是生成一个特征，该特征将为所需元素Dim strCode strCode = "0001" Dim objFSO, objFile, objRegEx Set objFSO = CreateObject("Scripting.FileSystemObject") Set objRegEx = CreateObject("VBScript.RegExp") objRegEx.Pattern = strCode & 'This is where I'm not sure exactly how to apply RegEx Dim afterMid Dim n n = 4 Dim result Dim newString Dim LogFile LogFile = "c:\Users\runto\Documents\Test Logfile.txt" Set objFile = objFSO.OpenTextFile(LogFile,1) Do Until objFile.AtEndOfStream strSearchString = objFile.ReadLine Set colMatches = objRegEx.Execute(strSearchString) If colMatches.Count > 0 Then For Each strCode in colMatches newString = strSearchString Next End If Loop MsgBox newString输出std::tuple<T>和为非所需元素输出T，并使用std::tuple_cat将这些元组重组为一个单一类型。例如：

std::tuple<>

其中#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> {};

Answer 3

您可以使用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和递归。我从一个空的元组开始，然后一次添加一个元素。

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

3 个答案: