Make struct behave like std::tuple - c++

Question

I've written some generic code which manages a list of tuples. Now I want to use that code, but instead of std::tuple I would like to use simple structs, so I can access the variables using names instead of indicies. Is there an easy way to make these structs behave like std::tuple, so I can use it with my generic code?
struct foo {
int x;
float y;
// some code to enable tuple like behavior (e.g. std::get, std::tuple_size)
};
I've tried adding a as_tuple member function which returns all members using std::tie. This works but requires to call this member function at all places where I need the tuple behavior.

Answer 1

The manual way:
struct foo {
int x;
float y;
};
namespace std
{
template <>
class tuple_element<0, foo> {
using type = int;
};
template <>
class tuple_element<1, foo> {
using type = float;
};
template <std::size_t I>
tuple_element_t<I, foo>& get(foo&);
template <>
tuple_element_t<0, foo>& get(foo& f) { return f.x;}
template <>
tuple_element_t<1, foo>& get(foo& f) { return f.y; }
template <std::size_t I>
tuple_element_t<I, foo> get(const foo&);
template <>
tuple_element_t<0, foo> get(const foo& f) { return f.x;}
template <>
tuple_element_t<1, foo> get(const foo& f) { return f.y; }
}
An other way is to write functions as_tuple:
template <typename ... Ts>
std::tuple<Ts...>& as_tuple(std::tuple<Ts...>& tuple) { return tuple; }
std::tuple<int&, float&> as_tuple(foo& f) { return std::tie(f.x, f.y); }
and wrap your call before using tuple-like.

Answer 2

First, as_tuple should be a free function in the namespace of the class. This lets you extend types other people write.
Next, you should attempt to call get in an ADL-enabled context.
using std::get;
auto& x = get<1>(foo);
if you do that we can pull off some magic.
struct get_from_as_tuple {
template<std::size_t I,
class T,
std::enable_if_t< std::is_base_of< get_from_as_tuple, std::decay_t<T> >, bool > = true
>
friend decltype(auto) get( T&& t ) {
return std::get<I>( as_tuple( std::forward<T>(t) ) );
}
};
now
struct foo:get_from_as_tuple {
int x;
float y;
friend auto as_tuple( get_from_as_tuple const& self ) {
return std::tie( self.x, self.y );
}
};
we can do this:
foo f;
using std::get;
std::cout << get<0>(f) << "," << get<1>(f) << "\n";
Now, this still doesn't enable tuple_size and tuple_element.
There is no trivial way to do that part, but we can work around it.
#define RETURNS(...) \
noexcept(noexcept(__VA_ARGS__)) \
-> decltype(__VA_ARGS__) \
{ return __VA_ARGS__; }
namespace tup {
namespace adl_get {
using std::get;
template<std::size_t I,
class T
>
auto get_helper( T&& t )
RETURNS( get<I>(std::forward<T>(t) ) )
}
template<std::size_t I, class T>
auto get( T&& t )
RETURNS(adl_get::get_helper<I>(std::forward<T>(t)))
}
now tup::get<7>( x ) will dispatch to either std::get or another get in x's namespace based off of overload resolution rules.
We can create similar helpers:
namespace util {
template<class T>
struct tag_t {constexpr tag_t(){}};
template<class T>
constexpr tag_t<T> tag{};
}
namespace tup {
namespace adl_tuple_size {
template<class T>
constexpr std::size_t get_tuple_size( tag_t<T>, ... ) {
return std::tuple_size<T>::value;
}
template<class T>
constexpr auto get_tuple_size( tag_t<T>, int )
RETURNS( tuple_size( tag_t<T> ) )
}
template<class T>
constexpr std::size_t tuple_size() {
return adl_tuple_size::get_tuple_size( tag<T> );
}
}
now tup::tuple_size<Foo>() is a constexpr call that gets the size of Foo by either (A) invoking tuple_size( tag_t<Foo> ) in an ADL-enabled context, or (B) returning std::tuple_size<Foo>::value.
Once we have this we can create another helper base type:
struct tuple_size_from_as_tuple {
template<std::size_t I,
class T,
std::enable_if_t< std::is_base_of< get_from_as_tuple, std::decay_t<T> >, bool > = true
>
friend std::size_t tuple_size( T&& t ) {
return std::tuple_size< decltype(as_tuple( std::forward<T>(t) ) ) >::value;
}
};
struct as_tuple_helpers : get_from_as_tuple, tuple_size_from_as_tuple {};
struct foo:as_tuple_helpers {
// ..
};
and we now have 2 primitives.
Repeat this for tag_t<E&> tuple_element( tag_t<T> ). Then we can write a tup::tuple_element<T, 0> alias that dispatches as you like it.
Finally, adapt your existing code that works with std:: tuple facilities to use tup:: facilities. It should work with existing tuple code, and will also work with types inherited from as_tuple_helper which has a friend as_tuple defined.
This does not, however, give you support for structured bindings.