Revision e5762014-8b02-466a-b9db-ca32b401d74c - Code Review Stack Exchange

I have written a simple (read: incomplete) tuple implementation that, AFAICT, does not violate the standard layout requirements. It's largely based on [Nish's implementation][1], but I use a recursive hierarchy of nested members, rather than recursive inheritance. Unfortunately this approach necessitates recursion for element access. But for my purposes I am willing to sacrifice compilation time for a predictable memory layout... my tuple stores elements in the "correct" order.

Aside from lengthy compilation times, are there any obvious flaws to this approach?

 #include <cstddef>
 #include <type_traits>
 
 template <class... Ts>
 struct tuple;
 
 template <class T, class... Ts>
 struct tuple<T, Ts...>
 {
 T first;
 tuple<Ts...> rest;	
 };
 
 template <class T>
 struct tuple<T>
 {
 T first;
 };
 
 
 namespace detail {
 
 template < ::std::size_t i, class T>
 struct tuple_element;

 template < ::std::size_t i, class T, class... Ts>
 struct tuple_element<i, tuple<T, Ts...> >
 : tuple_element<i - 1, tuple<Ts...> >
 {};
 
 template <class T, class... Ts>
 struct tuple_element<0, tuple<T, Ts...> >
 {
 using type = T;
 };
 
 
 template < ::std::size_t i>
 struct tuple_accessor
 {
 template <class... Ts>
 static inline typename tuple_element<i, tuple<Ts...> >::type & get (tuple<Ts...> & t)
 {
 return tuple_accessor<i - 1>::get(t.rest);
 }
 
 template <class... Ts>
 static inline const typename tuple_element<i, tuple<Ts...> >::type & get (const tuple<Ts...> & t)
 {
 return tuple_accessor<i - 1>::get(t.rest);
 }
 };
 
 template <>
 struct tuple_accessor<0>
 {
 template <class... Ts>
 static inline typename tuple_element<0, tuple<Ts...> >::type & get (tuple<Ts...> & t)
 {
 return t.first;
 }
 
 template <class... Ts>
 static inline const typename tuple_element<0, tuple<Ts...> >::type & get (const tuple<Ts...> & t)
 {
 return t.first;
 }
 };
 
 
 template <class T, class... Ts>
 struct tuple_builder
 {
 static inline void make (tuple<typename ::std::decay<T>::type, typename ::std::decay<Ts>::type...> & t, T && x, Ts &&... xs)
 {
 t.first = x;
 tuple_builder<Ts...>::make(t.rest, ::std::forward<Ts>(xs)...);
 }
 };
 
 template <class T>
 struct tuple_builder<T>
 {
 static inline void make (tuple<typename ::std::decay<T>::type> & t, T && x)
 {
 t.first = x;
 }
 };
 
 } // namespace detail
 
 
 
 template <class... Ts>
 inline tuple<typename ::std::decay<Ts>::type...> make_tuple (Ts &&... x)
 {
 tuple<typename ::std::decay<Ts>::type...> t;
 detail::tuple_builder<Ts...>::make(t, ::std::forward<Ts>(x)...);
 return t;
 }
 
 template < ::std::size_t i, class... Ts>
 inline typename detail::tuple_element<i, tuple<Ts...> >::type & get (tuple<Ts...> & t)
 {
 return detail::tuple_accessor<i>::get(t);
 }
 
 template < ::std::size_t i, class... Ts>
 inline const typename detail::tuple_element<i, tuple<Ts...> >::type & get (const tuple<Ts...> & t)
 {
 return detail::tuple_accessor<i>::get(t);
 }
 
 
 
 static_assert(::std::is_standard_layout<tuple<bool, int, float, char, double, tuple<int, char> > >(), "Compiler is stupid");

For more context, see [this][2]

[1]: http://voidnish.wordpress.com/2013/07/13/tuple-implementation-via-variadic-templates/
[2]: https://stackoverflow.com/questions/9833625/stdtuple-and-standard-layout