1

在这里http://en.cppreference.com/w/cpp/utility/tuple/tuple_element给出了 std::tuple_element 的可能实现。

 template< std::size_t I, class T >
struct tuple_element;

// recursive case
template< std::size_t I, class Head, class... Tail >
struct tuple_element<I, std::tuple<Head, Tail...>>
    : std::tuple_element<I-1, std::tuple<Tail...>> { };

// base case
template< class Head, class... Tail >
struct tuple_element<0, std::tuple<Head, Tail...>> {
   typedef Head type;
};

但是，如果元组有很多参数（超过 100 或 200 个参数），这个实现需要深度递归实例化。

Q1：为什么C++11没有添加特殊操作符来按索引获取元素？像 tuple[2] 或 tuple[0] ？

Q2：是否可以减少深度实例化？例如，在 D 语言中，更多的模板算法（在 typetuple 中）需要 O(log(N) ) 深度实例化。

编辑： Q1：为什么 C++11 没有添加特殊运算符来按索引从可变参数模板中获取元素？像模板< class ...T> struct index{ typedef T[3] third_element;}

4

3 回答 3

7

我认为这个实现有 O(log(N)) 实例化深度；对Xeo的 O(log(N)) 索引技巧表示敬意（修改为使用std::size_t而不是unsigned）。

编辑：我意识到有一种不同的、更简单且可能更快（编译时间）的解决方案来获得第 n 种类型的元组。

// from https://stackoverflow.com/a/13073076
// indices trick in O(log(N)) instantiations, by Xeo

    // using aliases for cleaner syntax
    template<class T> using Invoke = typename T::type;

    template<std::size_t...> struct seq{ using type = seq; };

    template<class S1, class S2> struct concat;

    template<std::size_t... I1, std::size_t... I2>
    struct concat<seq<I1...>, seq<I2...>>
      : seq<I1..., (sizeof...(I1)+I2)...>{};

    template<class S1, class S2>
    using Concat = Invoke<concat<S1, S2>>;

    template<std::size_t N> struct gen_seq;
    template<std::size_t N> using GenSeq = Invoke<gen_seq<N>>;

    template<std::size_t N>
    struct gen_seq : Concat<GenSeq<N/2>, GenSeq<N - N/2>>{};

    template<> struct gen_seq<0> : seq<>{};
    template<> struct gen_seq<1> : seq<0>{};

/ 的实现类似于std::tuple_element：

namespace detail
{
    template<std::size_t>
    struct Any
    {
        Any(...) {}
    };

    template<typename T>
    struct wrapper { using type = T; };

    template<std::size_t... Is>
    struct get_nth_helper
    {
        template<typename T>
        static auto deduce(Any<Is>..., wrapper<T>, ...) -> wrapper<T>;
    };

    template<std::size_t... Is, typename... Ts>
    auto deduce_seq(seq<Is...>, wrapper<Ts>... pp)
    -> decltype( get_nth_helper<Is...>::deduce(pp...) );
}

#include <tuple>

template<std::size_t n, class Tuple>
struct tuple_element;

template<std::size_t n, class... Ts>
struct tuple_element<n, std::tuple<Ts...>>
{
    using wrapped_type = decltype( detail::deduce_seq(gen_seq<n>{},
                                                      detail::wrapper<Ts>()...) );
    using type = typename wrapped_type::type;
};

使用示例：

#include <typeinfo>
#include <iostream>

int main()
{
    std::tuple<int, double, bool, char> t;
    tuple_element<1, decltype(t)>::type x;
    std::cout << typeid(x).name() << std::endl;
}

感谢@Barry在此答案的早期版本中指出了函数/数组类型的问题，并提供了修复。

原始版本：（注：此版本为简化版，不添加 cv-qualifiers。）

#include <tuple>


namespace detail
{
    template < std::size_t Index, class Arg >
    struct s_get_one
    {
        // declare a function that links an Index with an Arg type
        friend Arg get(s_get_one, std::integral_constant<std::size_t, Index>);
    };

    template < typename... Bases >
    struct s_get : Bases... {};
}

template < std::size_t I, class T >
struct tuple_element;

template < std::size_t I, class... Args >
struct tuple_element < I, std::tuple<Args...> >
{
    template<class T>
    struct wrapper { using type = T; };

    // deduce indices from seq helper
    template < std::size_t... Is >
    static auto helper(seq<Is...>)
        -> detail::s_get< detail::s_get_one<Is, wrapper<Args>>... >;

    // generate indices in O(log(N)) and use name lookup to find the type
    using IC = std::integral_constant<std::size_t, I>;
    using wrapped_type = decltype( get(helper(gen_seq<sizeof...(Args)>{}), IC{}) );
    using type = typename wrapped_type::type;
};
于 2013-09-03T14:01:44.443 回答
4

为什么 C++11 没有添加特殊运算符来按索引获取元素？像元组2或元组 [0] ？

首先，因为即使他们这样做了，它仍然会以相同的方式工作：使用递归。元组主要是库功能。尽管它们捎带了可变参数模板等语言特性，但它们在 C++98/03 中或多或少具有功能性。

其次，这是不可能的。并非没有非常困难的语言变化。

不清楚你的意思是什么tuple[2]。

如果您的意思是std::tuple<int, float, std::string>[2]应该以某种方式解析为 typename std::string，那么这意味着您现在需要解释为什么这样做。同样，元组是一种库特性，而不是一种语言结构。所以必须有一些语言结构，typename[integer]这是一个有效的结构。那会是什么，这意味着什么？

如果你的意思是给定的：

std::tuple<int, float, std::string> tpl{...};

我们应该能够得到带有 的字符串tpl[2]，这是“不会发生”的几种阴影。C++ 是一种静态类型语言。唯一std::get能够摆脱它的原因是整数索引不是函数参数；它是一个模板参数。这就是允许std::get<0>从std::get<2>. 这不会发生在operator[](int); 该函数必须始终返回相同的类型。

所以现在你需要有类似的东西template<class T, int i> ... operator[]()。这将非常令人困惑，因为您不能再tpl[runtimeValue]对那种类型进行操作（因为模板参数必须是编译时值）。没有这样的类型operator[]被限制在运行时值上工作。所以你会创建一个非常古怪的类型。

即便如此......它仍然需要进行递归才能获得价值。

是否可以减少深度实例化？

在编译时间之外（这不是一个不合理的问题），这有什么关系？一个体面的内联将把它们中的大部分扔掉。

至于编译时间，有各种特性的非递归实现std::tuple。他们是否可以tuple_element非递归地做，我不这么认为。这个 libc++ 实现似乎表明它不能，尽管tuple它本身是非递归实现的。

于 2013-09-03T13:31:51.557 回答
4 
    template< int ...i> struct seq{};

   // GCC couldn't optimize sizeof..(i) , 
   //see http://stackoverflow.com/questions/19783205/why-sizeof-t-so-slow-implement-c14-make-index-sequence-without-sizeof
   //so I use direct variable `s` instead of it.
   // i.e.  s == number of variadic arguments in `I`.
    template< int s, typename I, typename J > struct concate;

    template< int s, int ...i, int ...j>
    struct concate<s, seq<i...>, seq<j...> >
    { 
        typedef seq<i..., (s  + j)...> type;
    };

    template<int n> struct make_seq_impl;
    template< int n> using make_seq = typename make_seq_impl<n>::type;

    template<> struct make_seq_impl<0>{ typedef seq<> type;};
    template<> struct make_seq_impl<1>{ typedef seq<0> type;};

    template<int n> struct make_seq_impl: concate< n/2, make_seq<n/2>, make_seq<n-n/2>>{};

    template< typename ...T> using seq_for = make_seq< sizeof...(T) > ;

//----------------------------------
template< int i, typename T> struct id{};
template< typename T> struct id<0,T>{ typedef T type;};
template< typename ...T> struct base : T ... {};

template< typename ...T> struct tuple{};

template< std::size_t i, typename Tuple> struct tuple_element;

template< std::size_t i, typename ...T>
struct tuple_element< i, tuple<T...> >
{
      template< typename Seq > struct apply;
      template< int ...j > struct apply< seq<j...> >
      {
         // j xor i ==> ( 0 xor i), (1 xor i), (2 xor i ),...(i xor i) ...
         //    =>  i0, i1, ..., 0 (at pos i) ...
         // and only id<0,T> has `type`.
          typedef base< id< (j xor i), T> ... > base_t;
          typedef typename base_t::type type;
       };

     typedef typename apply< seq_for<T...> >::type type;
};
于 2013-11-18T10:46:56.317 回答