function parameter pack for member variable pointer - c++

Question

I am trying to access variables in a struct thru nested member pointers:
#include <iostream>
typedef struct {
int a;
int b;
} bar;
typedef struct {
int c;
bar d;
} baz;
template <typename obj, class C1, class C2, typename T1, typename T2>
T2 test1(const obj& obj_, T1 C1::* field1_, T2 C2::* field2_)
{
return (obj_.*field1_).*field2_;
}
int main()
{
baz myObj;
test1(myObj, &baz::d, &bar::b);
}
How would I turn the function test into a variadic function, so that i can access variables at variable "depths" into the struct?
I've tried to follow the second example in the Function parameter list section here, but am not getting it it seems:
template <typename obj, class ...C, typename... T>
void test2(const obj& obj_, T C...::* field_)
{
// ??
// and what about the function return parameter?
}
int main()
{
baz myObj;
test2(obj,&baz::d,&bar::b);
test2(obj,&baz::c);
}
With this, the definition of test2() already doesn't compile.
Any (latest) version of C++ can be used (with MSVC though).
For tests purpose, here is a complete program on coliru.
Solution
Thanks to Silvio's answer, I was able to solve it. Taking advantage of C++17, it can be made slightly shorter still:
template <typename T, typename S, typename... Ss>
auto inline test2(const T& obj, S field1, Ss... fields)
{
if constexpr (!sizeof...(fields))
return obj.*field1;
else
return test2(obj.*field1, fields...);
}

Answer 1

There may be a cleaner way to do this, but you can certainly take the "throw it at the wall and see what sticks" approach that C++ templates love so much.
template <typename T>
auto test2(const T& obj) -> T {
return obj;
}
template <typename T, typename S, typename... Ss>
auto test2(const T& obj, S field1, Ss... fields)
-> decltype(test2(obj.*field1, fields...)) {
return test2(obj.*field1, fields...);
}
The base case is pretty straightforward. If we don't pass any fields, we just return the original object itself. The recursive case is just that: we recurse. The return type is declared to be... the declared type of the return value. The argument types are simply variables. They'll be instantiated fully as needed. If you pass arguments that don't make sense or don't type check, you'll get some wonderfully ugly error messages.

Answer 2

This requires c++17 support for folding expressions.
namespace utils {
template<class T>struct tag_t{ using type=T; };
template<class...Ts>
using last = typename std::tuple_element_t< sizeof...(Ts)-1, std::tuple<tag_t<Ts>...> >::type;
template<class Lhs, class F>
struct fold_invoker_t;
template<class Lhs, class F>
fold_invoker_t<Lhs, F> fold_invoker(Lhs&&lhs, F&& f);
template<class Lhs, class F>
struct fold_invoker_t {
Lhs lhs;
F f;
template<class Rhs>
auto operator*( Rhs&& rhs )&& {
return fold_invoker(std::forward<F>(f)(std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)), static_cast<F>(f));
}
};
template<class Lhs, class F>
fold_invoker_t<Lhs, F> fold_invoker(Lhs&&lhs, F&& f){ return {std::forward<Lhs>(lhs), std::forward<F>(f)}; }
}
then we write:
template <typename Obj, class ...C, typename... T>
utils::last<Obj, T...> const& test2(const Obj& obj, T C::*... field)
{
auto get_member=[](auto&& elem, auto&& memptr)->decltype(auto){ return elem.*memptr; };
return (utils::fold_invoker( obj, get_member ) * ... * field).lhs;
}
and it is all expanded on that one line.
live example.
No idea if this will work in MSVC's C++17 support.