Question

为简单起见，我们使用std::tuple作为我们的类型列表。

在std::tuple中交换两种类型的最佳（简洁，最不递归等）方法是什么？

通过使用索引来说明功能：

#include <tuple>

int main()
{
    using tuple_t = std::tuple<int, void, double>;          // int, void, double
    using swapped_tuple_t = std::tuple<double, void, int>;  // double, void, int
    static_assert( std::is_same<swap<0, 2, tuple_t>::type, swapped_tuple_t>::value, "!" );
}

Answer 1

#include <tuple>
#include <utility>
#include <cstddef>

template <std::size_t I
        , std::size_t J
        , typename T
        , typename = std::make_index_sequence<I>
        , typename = std::make_index_sequence<J - I - 1>
        , typename = std::make_index_sequence<std::tuple_size<T>::value - J - 1>>
struct swap;

template <std::size_t I
        , std::size_t J
        , typename T
        , std::size_t... As
        , std::size_t... Bs
        , std::size_t... Cs>
struct swap<I, J, T
         , std::index_sequence<As...>
         , std::index_sequence<Bs...>
         , std::index_sequence<Cs...>
         >
{
    using type = std::tuple<typename std::tuple_element<As, T>::type...
                          , typename std::tuple_element<J, T>::type
                          , typename std::tuple_element<Bs + I + 1, T>::type...
                          , typename std::tuple_element<I, T>::type
                          , typename std::tuple_element<Cs + J + 1, T>::type...>;
};

DEMO

对于J可能低于或等于I的情况，请使用以下特征：

template <std::size_t I, std::size_t J, typename T>
struct swap : swap_impl<I<J?I:J, I<J?J:I, T> {};

template <std::size_t I, typename T>
struct swap<I,I,T>
{
    using type = T;
};

DEMO 2

Answer 2

没有理由使用三个序列。一个就够了：

template <std::size_t I
        , std::size_t J
        , typename T
        , typename = std::make_index_sequence<std::tuple_size<T>::value>>
struct swap_impl;

template <std::size_t I
        , std::size_t J
        , typename T
        , std::size_t... As>
struct swap_impl<I, J, T
               , std::index_sequence<As...>
         >
{
    using type = std::tuple<std::tuple_element_t<As == I ? J : As == J? I : As, T>... >;
};

template <std::size_t I, std::size_t J, typename T>
struct swap : swap_impl<I, J, T> {};

现在还没有必要特殊情况下I＆gt; = J案例。

Demo

Answer 3

我正在投入另一种选择（但我认为@Piotr的解决方案更优雅）。

template <size_t ...>
struct seq { };

// X, Y are the indeces we want to swap
template <size_t N, size_t X, size_t Y, size_t ...S>
struct gen : gen<N-1, X, Y, (N-1 == X ? Y : (N-1 == Y ? X : N - 1)), S...> { };

template <size_t X, size_t Y, size_t ...S>
struct gen<0, X, Y, S...> {
  typedef seq<S...> type;
};

// X and Y are the index we want to swap, T is the tuple
template <size_t X, size_t Y, class T, class S>
struct swapImpl;

template <size_t X, size_t Y, class T, size_t... S>
struct swapImpl<X, Y, T, seq<S...>>{
    using type = std::tuple<typename std::tuple_element<S, T>::type...>;
};

template <size_t X, size_t Y, class T>
struct swap {
    using type = typename swapImpl<X, Y, T, 
                         typename gen<std::tuple_size<T>::value, X, Y>::type>::type;
};

int main() {
  using tuple_t = std::tuple<int, unsigned, void, char, double>;          // int, void, double
  using swapped_tuple_a_t = std::tuple<unsigned, int, void, char, double>;  // double, void, int
  static_assert( std::is_same<swap<0, 1, tuple_t>::type, swapped_tuple_a_t>::value, "!" );
  static_assert( std::is_same<swap<1, 0, tuple_t>::type, swapped_tuple_a_t>::value, "!" );
  using swapped_tuple_b_t = std::tuple<int, char, void, unsigned, double>;  // double, void, int
  static_assert( std::is_same<swap<1, 3, tuple_t>::type, swapped_tuple_b_t>::value, "!" );
  static_assert( std::is_same<swap<3, 1, tuple_t>::type, swapped_tuple_b_t>::value, "!" );
}

在类型列表中交换两种类型

3 个答案: