c++ - 如何拆分元组？

Question

给定一个

   template<typename First, typename... Tail>
   struct something
   {
       std::tuple<First, Tail...> t;
   };

我怎样才能得到 std::tuple<Tail...>包含来自 t 的所有元素除了第一个？

---

总的来说，我认为这是一个有趣的问题，但这是我的上下文动机:

我想为元组实现哈希。我用了this answer作为基础。我发现里面有一个错误，即没有调用operator()具有值的哈希对象:

return left() ^ right();

应该是:

return left(std::get<0>(e)) ^ right(???);

？？？将是元组的剩余元素以继续模板的递归实例化。这是包含终止部分的完整代码:

#include <functional>
#include <utility>

namespace std
{

template<typename First, typename... Tail>
struct hash<std::tuple<First, Tail...>>
{
    typedef size_t result_type;
    typedef std::tuple<First, Tail...> argument_type;

    result_type operator()(argument_type const& e) const
    {
        std::hash<First> left;
        std::hash<std::tuple<Tail...>> right;
        return left(std::get<0>(e)) ^ right(???);
    }
};

template<>
struct hash<std::tuple<>>
{
    typedef size_t result_type;
    typedef std::tuple<> argument_type;

    result_type operator()(argument_type const& e) const
    {
        return 1;
    }
};

}

Answer 1

我正在寻找同样的东西，并想出了这个相当直接的 C++14 解决方案:

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

template < typename T , typename... Ts >
auto head( std::tuple<T,Ts...> t )
{
   return  std::get<0>(t);
}

template < std::size_t... Ns , typename... Ts >
auto tail_impl( std::index_sequence<Ns...> , std::tuple<Ts...> t )
{
   return  std::make_tuple( std::get<Ns+1u>(t)... );
}

template < typename... Ts >
auto tail( std::tuple<Ts...> t )
{
   return  tail_impl( std::make_index_sequence<sizeof...(Ts) - 1u>() , t );
}

int main()
{
   auto t = std::make_tuple( 2, 3.14 , 'c' );
   std::cout << head(t) << std::endl;
   std::cout << std::get<0>( tail(t) ) << std::endl;
   std::cout << std::get<1>( tail(t) ) << std::endl;
}

因此，head(.) 返回元组的第一个元素，tail(.) 返回仅包含最后 N-1 个元素的新元组。