Pointer to a member's member - c++

Question

C++ allows one to define pointers to members of a class like:
struct A
{
int i;
};
void a()
{
int A::*p = &A::i;
}
but what if I want a pointer to a member that's on a deeper "level" like this?
struct A
{
int i;
struct B{int j;};
B b;
};
void a()
{
int A::*p = &A::b::j;
}
Theoretically it seems that if pointer to members are compiled to offets from the start of the object this could have been easily supported by the language although things like virtual/diamond inheritance would probably make this far too complicated
What's the easiest way to achieve that without performance penalties or undefined behaviour?
My first idea was to just use an offset and work with raw pointers on the object but that seems like it might not be defined behaviour and would also make it impossible for the compiler to detect if I'm pointing to actual fields with the correct type

Answer 1

You can only define a pointer to data member for a given class for actual data members of that class.
That you have a nested class type declared is no special case here: you can extract a pointer a data member of A::B and apply the pointer to data member onto the b member (of type A::B) of an A object:
#include <iostream>
struct A {
int i;
struct B{ int j; };
B b;
};
int main() {
A a{1, {42}}; // a.b.j is 42
// Declare a pointer-to-data-member of B (which
// is a nested class in A).
int A::B::*p = &A::B::j;
// Apply to an actual 'B' object to retrieve
// the data member value pointed to.
std::cout << a.b.*p; // 42
}
However if you want to apply a pointer to data member on an A object, the best you can get is a pointer to the data member b.
You could always use nested pointer to data member pointers for a nested class objects:
int main() {
A a{1, {42}}; // a.b.j is 42
A::B A::*pb = &A::b;
int A::B::*pj = &A::B::j;
std::cout << (a.*pb).*pj; // 42
}

Answer 2

Just for the sake of showing that what I want isn't impossible in C++ I'll provide following solution:
// Example program
#include <iostream>
#include <string>
#include <memory>
template<typename T, typename P>
class MemberPointer
{
public:
virtual P& access(T& obj) = 0;
};
template<typename T, typename P>
class SimpleMemberPointer : public MemberPointer<T, P>
{
P T::*ptr;
public:
SimpleMemberPointer(P T::*ptr): ptr(ptr){}
P& access(T& obj) override
{
return obj.*ptr;
}
using object = T;
using property = P;
};
template<typename Ptr, typename P>
class NestedMemberPointer : public MemberPointer<typename Ptr::object, P>
{
public:
using object = typename Ptr::object;
using property = P;
private:
using intermediate = typename Ptr::property;
Ptr parent;
P intermediate::*ptr;
public:
NestedMemberPointer(Ptr parent, P intermediate::*ptr): parent(parent), ptr(ptr){}
P& access(object& obj) override
{
return parent.access(obj).*ptr;
}
};
Sample usage code:
class Person
{
public:
std::string name;
struct Address{
std::string street;
}address;
};
void test(Person &p, MemberPointer<Person, std::string> &ptr)
{
std::cout << ptr.access(p) << std::endl;
}
int main()
{
Person p{"Jim", {"Street"}};
std::unique_ptr<MemberPointer<Person, std::string>> ptr = std::make_unique<SimpleMemberPointer<Person, std::string>>(&Person::name);
std::unique_ptr<MemberPointer<Person, std::string>> ptr2 = std::make_unique<NestedMemberPointer<SimpleMemberPointer<Person, Person::Address>, std::string>>(SimpleMemberPointer<Person, Person::Address>{&Person::address}, &Person::Address::street);
test(p, *ptr);
test(p, *ptr2);
}
ptr and ptr2 are variables of the same type despite refering to members in different depth, just as I want.
If executed the program prints
Jim
Street
Now the only problem with this solution is that it's not really simple and also not very performant given that it requires rather complicated variable definitions and needs polymorphism to differentiate on different paths