如何反轉元組類型中元素類型的順序？

如何反轉元組中的類型？例如，我想要reverse_tuple<std::tuple<int, char, bool>>::type爲std::tuple<bool, char, int>。我試着做了以下，但它沒有奏效。我做錯了什麼？如何反轉元組類型中元素類型的順序？

#include <type_traits> 
#include <tuple> 

template <typename... Ts> 
struct tuple_reverse; 

template <typename T, typename... Ts> 
struct tuple_reverse<std::tuple<T, Ts...>> 
{ 
    using type = typename tuple_reverse< 
          std::tuple< 
           typename tuple_reverse<std::tuple<Ts..., T>>::type 
          > 
          >::type; 
}; 

template <typename T> 
struct tuple_reverse<std::tuple<T>> 
{ 
    using type = std::tuple<T>; 
}; 

int main() 
{ 
    using result_type = std::tuple<int, bool, char>; 
    static_assert(
     std::is_same< 
      tuple_reverse<var>::type, std::tuple<char, bool, int> 
     >::value, "" 
    ); 
}

這裏是我的錯誤：

prog.cpp: In instantiation of ‘struct tuple_reverse<std::tuple<char, int, bool> >’:
prog.cpp:15:34: recursively required from ‘struct tuple_reverse<std::tuple<bool, char, int> >’
prog.cpp:15:34: required from ‘struct tuple_reverse<std::tuple<int, bool, char> >’
prog.cpp:29:31: required from here
prog.cpp:15:34: error: no type named ‘type’ in ‘struct tuple_reverse<std::tuple<int, bool, char> >’
prog.cpp: In function ‘int main()’:
prog.cpp:30:9: error: template argument 1 is invalid

來源

2013-06-18 Me myself and I

我不認爲你需要遞歸做到這一點，[tuple_cat（http://www.cplusplus.com/reference/tuple/tuple_cat/），但你爲什麼要扭轉一個元組 – aaronman

你做了什麼錯在這裏：

using type = typename tuple_reverse< 
         std::tuple< 
          typename tuple_reverse<std::tuple<Ts..., T>>::type 
         > 
         >::type;

由內而外的看着它，你重新排序的元組元素：tuple<Ts..., T>，然後嘗試扭轉，那麼你把結果在tuple，那麼你試着反轉即 ......呵呵？！ :)

這意味着每次你實例化tuple_reverse你給它一個相同大小的元組，所以它永遠不會結束，並且遞歸地永久實例化自己。（然後，如果這個遞歸甚至完成了，你把得到的元組類型放入一個元組中，所以你有一個包含N元組元組的元素元組，並且相反，它什麼都不做，因爲反轉單元元組是一個無操作）

你要剝離的元素之一，然後反轉休息，然後再返回串連它：

using head = std::tuple<T>; 
using tail = typename tuple_reverse<std::tuple<Ts...>>::type; 

using type = decltype(std::tuple_cat(std::declval<tail>(), std::declval<head>()));

而且你不需要包裝在一個元組和再反過來:)

而且你還應該處理空元組的情況下，所以整個事情是：

template <typename... Ts> 
struct tuple_reverse; 

template <> 
struct tuple_reverse<std::tuple<>> 
{ 
    using type = std::tuple<>; 
}; 

template <typename T, typename... Ts> 
struct tuple_reverse<std::tuple<T, Ts...>> 
{ 
    using head = std::tuple<T>; 
    using tail = typename tuple_reverse<std::tuple<Ts...>>::type; 

    using type = decltype(std::tuple_cat(std::declval<tail>(), std::declval<head>())); 
};

雖然我會做不同的。

得到公正的類型，使用C++ 14

template<typename T, size_t... I> 
struct tuple_reverse_impl<T, std::index_sequence<I...>> 
{ 
    typedef std::tuple<typename std::tuple_element<sizeof...(I) - 1 - I, T>::type...> type; 
}; 

// partial specialization for handling empty tuples: 
template<typename T> 
struct tuple_reverse_impl<T, std::index_sequence<>> 
{ 
    typedef T type; 
}; 

template<typename T> 
struct tuple_reverse<T> 
: tuple_reverse_impl<T, std::make_index_sequence<std::tuple_size<T>::value>> 
{ };

或者，您可以編寫一個函數來扭轉實際元組對象，然後使用decltype(reverse(t))獲得的類型。扭轉C++ 14的元組狀物體：

template<typename T, size_t... I> 
auto 
reverse_impl(T&& t, std::index_sequence<I...>) 
{ 
    return std::make_tuple(std::get<sizeof...(I) - 1 - I>(std::forward<T>(t))...); 
} 

template<typename T> 
auto 
reverse(T&& t) 
{ 
    return reverse_impl(std::forward<T>(t), 
         std::make_index_sequence<std::tuple_size<T>::value>()); 
}

在C++ 11使用<integer_seq.h>並添加返回類型，並使用remove_reference剝離從元組類型的引用（因爲tuple_size和tuple_element不工作參考元組）：

template<typename T, typename TT = typename std::remove_reference<T>::type, size_t... I> 
auto 
reverse_impl(T&& t, redi::index_sequence<I...>) 
-> std::tuple<typename std::tuple_element<sizeof...(I) - 1 - I, TT>::type...> 
{ 
    return std::make_tuple(std::get<sizeof...(I) - 1 - I>(std::forward<T>(t))...); 
} 

template<typename T, typename TT = typename std::remove_reference<T>::type> 
auto 
reverse(T&& t) 
-> decltype(reverse_impl(std::forward<T>(t), 
         redi::make_index_sequence<std::tuple_size<TT>::value>())) 
{ 
    return reverse_impl(std::forward<T>(t), 
         redi::make_index_sequence<std::tuple_size<TT>::value>()); 
}

來源

2013-06-18 20:34:06

我如何在這方面與你一樣好？我從來沒有想過以這些驚人的方式寫出它！ :) –

練習，練習，練習。不過，不僅僅是C++，對於模板元編程，瞭解一些函數式編程技術也很有用。今天，我正在Python和OSC中編寫一個Web應用程序，只是爲了好玩，因爲我正在學習新的東西。 –

你知道我可以如何改進函數式編程嗎？你會推薦什麼？ –

未經檢驗。

template < typename Tuple, typename T > 
struct tuple_push; 

template < typename T, typename ... Args > 
struct tuple_push<std::tuple<Args...>, T> 
{ 
    typedef std::tuple<Args...,T> type; 
}; 

template < typename Tuple > 
struct tuple_reverse; 

template < typename T, typename ... Args > 
struct tuple_reverse<std::tuple<T, Args...>> 
{ 
    typedef typename tuple_push<typename tuple_reverse<std::tuple<Args...>>::type, T>::type type; 
}; 

template < > 
struct tuple_reverse<std::tuple<>> 
{ 
    typedef std::tuple<> type; 
};

反正有什麼事情。

這也只是反轉類型，這似乎是你在之後。反轉一個實際的元組將涉及函數，而不是元函數。

來源

2013-06-18 20:23:48

我在處理任意類型的反轉模板參數時遇到了這個問題。

喬納森Wakely的答案偉大的元組，但在其他人需要反轉任何類型，即T<P1, P2, ..., Pn>至T<Pn, Pn-1, ..., P1>，這是我想出了（Reversal logic taken from here）。

namespace Details 
{ 
    /// Get the base case template type `T<>` of a templated type `T<...>` 
    template<typename> 
    struct templated_base_case; 

    template <template<typename...> class T, typename... TArgs> 
    struct templated_base_case<T<TArgs...>> 
    { 
     using type = T<>; 
    }; 

    /// Inner reverse logic. 
    /// 
    /// Reverses the template parameters of a templated type `T` such 
    /// that `T<A, B, C>` becomes `T<C, B, A>`. 
    /// 
    /// Note that this requires `T<>` to exist. 
    template< 
     typename T, 
     typename = typename templated_base_case<T>::type> 
    struct reverse_impl; 

    template< 
     template <typename...> class T, 
     typename... TArgs> 
    struct reverse_impl< 
     typename templated_base_case<T<TArgs...>>::type, 
     T<TArgs...>> 
    { 
     using type = T<TArgs...>; 
    }; 

    template< 
     template<typename...> class T, 
     typename first, 
     typename... rest, 
     typename... done> 
    struct reverse_impl< 
     T<first, rest...>, 
     T<done...>> 
    { 
     using type = typename reverse_impl <T<rest...>, T<first, done...>>::type; 
    }; 

    /// Swap template parameters of two templated types. 
    /// 
    /// `L<A, B, C> and R<X, Y, Z>` become `L<X, Y, Z> and R<A, B, C>`. 
    template<typename L, typename R> 
    struct swap_template_parameters; 

    template< 
     template<typename...> class L, 
     template<typename...> class R, 
     typename... x, 
     typename... y> 
    struct swap_template_parameters<L<x...>, R<y...>> 
    { 
     using left_type = L<y...>; 
     using right_type = R<x...>; 
    }; 
} 

/// Parameter pack list of types 
template <typename... Args> 
struct type_list { }; 

/// Reverses the arguments of a templates type `T`. 
/// 
/// This uses a `type_list` to allow reversing types like std::pair 
/// where `std::pair<>` and `std::pair<T>` are not valid. 
template<typename T> 
struct reverse_type; 

template<template<typename...> class T, typename... TArgs> 
struct reverse_type<T<TArgs...>> 
{ 
    using type = typename Details::swap_template_parameters< 
     T<TArgs...>, 
     typename Details::reverse_impl<type_list<TArgs...>>::type>::left_type; 
};

某些實現邏輯可以合併，但我試圖在這裏儘可能清楚。

reverse_type可以應用到元組：

using my_tuple = std::tuple<int, bool, char>; 

static_assert(
    std::is_same< 
     typename reverse_type<my_typle>::type, 
     std::tuple<char, bool, int>>::value, 
    "");

或其他類型的：

/// Standard collections cannot be directly reversed easily 
/// because they take default template parameters such as Allocator. 
template<typename K, typename V> 
struct simple_map : std::unordered_map<K, V> { }; 

static_assert(
    std::is_same< 
     typename reverse_type<simple_map<std::string, int>>::type, 
     simple_map<int, std::string>>::value, 
    "");

Slightly more detailed explanation。

來源

2014-10-11 18:44:06

出於興趣，你真的想要顛倒一個元組類型，還是僅僅以相反的順序處理每個元素（在我的項目中更常見）？

#include <utility> 
#include <tuple> 
#include <iostream> 

namespace detail { 

    template<class F, class Tuple, std::size_t...Is> 
    auto invoke_over_tuple(F &&f, Tuple &&tuple, std::index_sequence<Is...>) { 
     using expand = int[]; 
     void(expand{0, 
        ((f(std::get<Is>(std::forward<Tuple>(tuple)))), 0)...}); 
    } 


    template<class Sequence, std::size_t I> 
    struct append; 
    template<std::size_t I, std::size_t...Is> 
    struct append<std::index_sequence<Is...>, I> { 
     using result = std::index_sequence<Is..., I>; 
    }; 

    template<class Sequence> 
    struct reverse; 

    template<> 
    struct reverse<std::index_sequence<>> { 
     using type = std::index_sequence<>; 
    }; 

    template<std::size_t I, std::size_t...Is> 
    struct reverse<std::index_sequence<I, Is...>> { 
     using subset = typename reverse<std::index_sequence<Is...>>::type; 
     using type = typename append<subset, I>::result; 
    }; 
} 

template<class Sequence> 
using reverse = typename detail::reverse<Sequence>::type; 

template 
     < 
       class Tuple, 
       class F 
     > 
auto forward_over_tuple(F &&f, Tuple &&tuple) { 
    using tuple_type = std::decay_t<Tuple>; 
    constexpr auto size = std::tuple_size<tuple_type>::value; 
    return detail::invoke_over_tuple(std::forward<F>(f), 
            std::forward<Tuple>(tuple), 
            std::make_index_sequence<size>()); 
}; 

template 
     < 
       class Tuple, 
       class F 
     > 
auto reverse_over_tuple(F &&f, Tuple &&tuple) { 
    using tuple_type = std::decay_t<Tuple>; 
    constexpr auto size = std::tuple_size<tuple_type>::value; 
    return detail::invoke_over_tuple(std::forward<F>(f), 
            std::forward<Tuple>(tuple), 
            reverse<std::make_index_sequence<size>>()); 
}; 

int main() 
{ 
    auto t = std::make_tuple("1", 2, 3.3, 4.4, 5, 6, "7"); 
    forward_over_tuple([](auto &&x) { std::cout << x << " "; }, t); 
    std::cout << std::endl; 

    reverse_over_tuple([](auto &&x) { std::cout << x << " "; }, t); 
    std::cout << std::endl; 
}

來源

2017-07-16 09:19:34

如何反轉元組類型中元素類型的順序？

回答

相關問題