Standard-layout tuple implementation (C++)
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 (http://voidnish.wordpress.com/2013/07/13/tuple-implementation-via-variadic-templates/Nish's implementation ), but I use a recursive hierarchy of nested members, rather than recursive inheritance. Unfortunately this approach necessitates recursion for element access, but. But for my purposes I am willing to sacrifice compilation time for a predictable memory layout... my tuple stores elements in the "correct" order.
For more context, see: http://stackoverflow.com/questions/9833625/stdtuple-and-standard-layoutthis
Thanks for reading!
Standard-layout tuple implementation (C++)
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 (http://voidnish.wordpress.com/2013/07/13/tuple-implementation-via-variadic-templates/ ) 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.
For more context, see: http://stackoverflow.com/questions/9833625/stdtuple-and-standard-layout
Thanks for reading!
Standard-layout tuple implementation
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 , 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.
For more context, see this
Standard-layout tuple implementation (C++)
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 (http://voidnish.wordpress.com/2013/07/13/tuple-implementation-via-variadic-templates/) 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: http://stackoverflow.com/questions/9833625/stdtuple-and-standard-layout
Thanks for reading!