给出
template<typename First, typename... Tail>
struct something
{
std::tuple<First, Tail...> t;
};
如何获得包含std::tuple<Tail...>
除{1}之外的所有元素的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;
}
};
}
答案 0 :(得分:12)
我正在寻找相同的东西,并提出了这个相当直接的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个元素的新元组。
答案 1 :(得分:4)
使用“索引元组”解压缩元组而不递归:
#include <redi/index_tuple.h>
template<typename T, typename... U, unsigned... I>
inline std::tuple<U...>
cdr_impl(const std::tuple<T, U...>& t, redi::index_tuple<I...>)
{ return std::tuple<U...>{ std::get<I+1>(t)... }; }
template<typename T, typename... U>
inline std::tuple<U...>
cdr(const std::tuple<T, U...>& t)
{ return cdr_impl(t, redi::to_index_tuple<U...>()); }
请参阅https://gitlab.com/redistd/redistd/blob/master/include/redi/index_tuple.h了解make_index_tuple
和index_tuple
这些是IMHO必不可少的实用程序,用于处理元组和类似的可变参数类模板。 (类似的实用程序在C ++ 14中标准化为std::index_sequence
,有关独立的C ++ 11实现,请参阅index_seq.h。
或者,使用std::tie
获取引用元组的非复制版本,而不是复制每个元素:
#include <redi/index_tuple.h>
template<typename T, typename... U, unsigned... I>
inline std::tuple<const U&...>
cdr_impl(const std::tuple<T, U...>& t, redi::index_tuple<I...>)
{ return std::tie( std::get<I+1>(t)... ); }
template<typename T, typename... U>
inline std::tuple<const U&...>
cdr(const std::tuple<T, U...>& t)
{ return cdr_impl(t, redi::to_index_tuple<U...>()); }
答案 2 :(得分:3)
这是我首先尝试的方法。可能更好的东西:
#include <tuple>
template < typename Target, typename Tuple, int N, bool end >
struct builder
{
template < typename ... Args >
static Target create(Tuple const& t, Args && ... args)
{
return builder<Target,Tuple, N+1, std::tuple_size<Tuple>::value == N+1>::create(t, std::forward<Args>(args)..., std::get<N>(t));
}
};
template < typename Target, typename Tuple, int N >
struct builder<Target,Tuple,N,true>
{
template < typename ... Args >
static Target create(Tuple const& t, Args && ... args) { return Target(std::forward<Args>(args)...); }
};
template < typename Head, typename ... Tail >
std::tuple<Tail...> cdr(std::tuple<Head,Tail...> const& tpl)
{
return builder<std::tuple<Tail...>, std::tuple<Head,Tail...>, 1, std::tuple_size<std::tuple<Head,Tail...>>::value == 1>::create(tpl);
}
#include <iostream>
int main() {
std::tuple<int,char,double> t1(42,'e',16.7);
std::tuple<char,double> t2 = cdr(t1);
std::cout << std::get<0>(t2) << std::endl;
}
有一点值得注意的是,如果你使用自己的类型而不是std :: tuple,你可能会好得多。这是如此困难的原因是,似乎标准没有指定这个元组如何工作,因为没有给出它继承自己。升级版使用了一个你可以挖掘的缺点。这里的内容可能更符合您的要求,这将使上述所有内容变得像演员一样简单:
template < typename ... Args > struct my_tuple;
template < typename Head, typename ... Tail >
struct my_tuple<Head,Tail...> : my_tuple<Tail...>
{
Head val;
template < typename T, typename ... Args >
my_tuple(T && t, Args && ... args)
: my_tuple<Tail...>(std::forward<Args>(args)...)
, val(std::forward<T>(t))
{}
};
template < >
struct my_tuple <>
{
};
这是未经测试的,但它应该说明足够的点,直到它工作。现在要获得一个类型为“tail”的对象,你只需:
template < typename Head, typename ... Tail >
my_tuple<Tail...> cdr(my_tuple<Head,Tail...> const& mtpl) { return mtpl; }
答案 3 :(得分:3)
Crazy Eddie找到了解开元组的方法,它确实回答了这个问题。但是,对于您提出的特定问题(即元组散列),为什么不避免使用所有元组副本,而是使用模板递归依次散列每个元素?
#include <utility>
#include <iostream>
template< typename T >
size_t left( T const & ) {
return 1;
}
template< int N, typename Head, typename... Tail >
struct _hash {
typedef size_t result_type;
typedef std::tuple< Head, Tail... > argument_type;
result_type operator ()( argument_type const &e ) const {
return left(std::get<N>(e)) ^ _hash<N-1, Head, Tail... >()(e);
}
}; // end struct _hash
template< typename Head, typename... Tail >
struct _hash< 0, Head, Tail... > {
typedef size_t result_type;
typedef std::tuple< Head, Tail... > argument_type;
result_type operator ()( argument_type const &e ) const {
return left(std::get<0>(e));
}
}; // end struct _hash< 0 >
template< typename Head, typename... Tail >
size_t hash( std::tuple< Head, Tail... > const &e ) {
return _hash< sizeof...(Tail), Head, Tail... >()( e );
}
int main( ) {
std::tuple< int > l_tuple( 5 );
std::cout << hash( l_tuple ) << std::endl;
}
这会以相反的顺序进行散列,但xors是可交换的,因此无关紧要。
答案 4 :(得分:1)
这样的事情:
#include <tuple>
template <bool, typename T, unsigned int ...N> struct tail_impl;
template <typename T, typename ...Args, unsigned int ...N>
struct tail_impl<false, std::tuple<T, Args...>, N...>
{
static std::tuple<Args...> go(std::tuple<T, Args...> const & x)
{
return tail_impl<sizeof...(N) + 1 == sizeof...(Args), std::tuple<T, Args...>, N..., sizeof...(N)>::go(x);
}
};
template <typename T, typename ...Args, unsigned int ...N>
struct tail_impl<true, std::tuple<T, Args...>, N...>
{
static std::tuple<Args...> go(std::tuple<T, Args...> const & x)
{
return std::tuple<Args...>(std::get<N>(x)...);
}
};
template <typename T, typename ...Args>
std::tuple<Args...> tail(std::tuple<T, Args...> const & x)
{
return tail_impl<sizeof...(Args) == 1, std::tuple<T, Args...>, 0>::go(x);
}
测试:
#include <demangle.hpp>
#include <iostream>
typedef std::tuple<int, char, bool> TType;
int main()
{
std::cout << demangle<TType>() << std::endl;
std::cout << demangle<decltype(tail(std::declval<TType>()))>() << std::endl;
}
打印:
std::tuple<int, char, bool>
std::tuple<char, bool>
答案 5 :(得分:0)
使用kgadek对get part of std::tuple和Andre Bergner的测试代码的回答。这很简单,但我不知道它是否便携。
// works using gcc 4.6.3
// g++ -std=c++0x -W -Wall -g main.cc -o main
#include <iostream>
#include <tuple>
template < typename T , typename... Ts >
const T& head(std::tuple<T,Ts...> t)
{
return std::get<0>(t);
}
template <typename T, typename... Ts>
const std::tuple<Ts...>& tail(const std::tuple<T, Ts...>& t)
{
return (const std::tuple<Ts...>&)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;
}