交换类型列表中的两个类型

Swapping two types in a type list

本文关键字：类型 两个 列表 交换      更新时间：2023-10-16

为了简单起见，让我们使用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, "!" );
}

#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...>;
};

演示

对于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;
};

演示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>=J的情况。

演示。

我提出了一个替代方案（但我认为@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, "!" );
}
相关文章：