Safe way to reference nested member - c++

Question

I have a struct with some other structs as member. Both external and internal structs are StandardLayout (it can be even assumed that internal are plain old data). Something like this:
struct Inner1 {
int a = 0, b = 0;
};
struct Inner2 {
int c = 0, d = 0;
};
struct Outer {
Inner1 x;
std::string s;
Inner2 y;
};
I want to write some function that takes Outer& and object of some type T that can return value of any nested field, depending on argument:
int get(Outer& o, T field);
If Outer was a flat structure, pointers to member would be exactly what I needed, however it is not flat.
The trivial way is to make T a enum of all fields and write a switch, but I it it not efficient. The faster way is to make T an offset and write
int get(Outer& o, size_t field) {
return *reinterpret_cast<int*>(reinterpret_cast<char*>(o) + field);
}
and then call it like get(o, offsetof(Outer, y) + offsetof(Inner2, c)). It works, but I am not sure if it is guaranteed to work - if it is correct to sum offsets like this and if it is safe to take member value by offset.
So, the question: is this way safe? If not, is there a safe way? Constructing values of T can be arbitrary complex, however using them should be fast.
Motivation: I will need to put values from some of nested fields in some order, known at startup, but not in compile time. I wanted to create an array of T at startup and then, when getting particular object, use this precalced array.
[UPD]: So it will be used like this:
void bar(int);
void foo(Outer& o, vector<T>& fields) {
for (auto& field : fields) {
bar(get(o, field));
}
}

Answer 1

You can do it this way.
/* main.cpp */
#include <string>
#include <iostream>
using namespace std;
struct Inner1 {
int a = 0, b = 0;
};
struct Inner2 {
int c = 0, d = 0;
};
struct Outer {
Inner1 x;
std::string s;
Inner2 y;
};
struct OuterMember
{
int (*getter)(Outer &obj);
};
inline int get(Outer &obj,OuterMember field) { return field.getter(obj); }
template <auto Ptr1,auto Ptr2>
auto GetInnerMember(Outer &obj) { return (obj.*Ptr1).*Ptr2; }
inline constexpr OuterMember OuterMemberA = { GetInnerMember<&Outer::x,&Inner1::a> } ;
inline constexpr OuterMember OuterMemberB = { GetInnerMember<&Outer::x,&Inner1::b> } ;
inline constexpr OuterMember OuterMemberC = { GetInnerMember<&Outer::y,&Inner2::c> } ;
inline constexpr OuterMember OuterMemberD = { GetInnerMember<&Outer::y,&Inner2::d> } ;
/* main() */
int main()
{
Outer obj;
obj.x.a=1;
obj.x.b=2;
obj.y.c=3;
obj.y.d=4;
cout << "a = " << get(obj,OuterMemberA) << endl ;
cout << "b = " << get(obj,OuterMemberB) << endl ;
cout << "c = " << get(obj,OuterMemberC) << endl ;
cout << "d = " << get(obj,OuterMemberD) << endl ;
return 0;
}

Answer 2

I do think this is safe (as in not a violation of strict aliasing).
However, the language does have a better mecanism for doing this: Pointers to data members, which compile down to basically an offset.
The caveat is that you'll have to make separate overloads for Inner1 and Inner2
int get(Outer& o, int Inner1::* m) {
return o.x.*m;
}
int get(Outer& o, int Inner2::* m) {
return o.y.*m;
}
int foo() {
Outer tmp;
return get(tmp, &Inner1::a) + get(tmp, &Inner2::d);
}

Answer 3

You can achieve the same using function template specialization see sample code below
#include <iostream>
using namespace std;
struct Inner1 {
int a = 1, b = 2;
};
struct Inner2 {
int c = 3, d = 4;
};
struct Outer {
Inner1 x;
std::string s;
Inner2 y;
};
template<typename T>
int get(Outer&o);
template<>
int get<Inner1>(Outer& o)
{
return o.x.a;
}
template<>
int get<Inner2>(Outer& o)
{
return o.y.c;
}
int main()
{
Outer out;
std::cout << get<Inner1>(out) << std::endl;
std::cout << get<Inner2>(out) << std::endl;
return 0;
}
I hope this helps!. The more interesting thing is that this is type safe.