Может ли объект-член, или объект-элемент достучаться к содержащему его?

class A
{
 ...
};
class B
{
 ....
 A a;
...
};
class C
{
 ...
 A *a;
 ...
}
...
B b1;
B *b2;
C c;
size_t i;
...

int * pA = &obj.a;

int A::* offsetA = &A::a;

A obj;
int v = (obj.*offsetA);

A * pObj;
int v = (pObj->*offsetA);

struct B
{
    void* func();
};
 
struct A
{
    int m; 
    int n;
    B b1;
    B b2;
};
 
void* B::func()
{
    B A::* q; // указатель на член класса ( член, имеющий тип B )
    q = &A::b1; //  0x00000008
 
    int* pInt2 = reinterpret_cast<int*>( &q ); // *pInt2 == 8 , т.е. sizeof(A::m) + sizeof(A::n)
 
    // чтобы получить адрес объекта-агрегата, из this вычитаем 8
    void* parent = reinterpret_cast<char*>(this) - *pInt2;
    return parent;
}
 
int main()
{
    A a;
    cout << "\n &a    " << &a << endl;
 
    void* p = a.b2.func();
    cout << "\n result of  a.b2.func()  " << p << endl;
 
    // ... 
}

/* добавим поле char, больше никаких изменений в коде нет (см. сообщение #20) */
struct A
{
    char c; 
    // ... 
};
/* Результат: 
 
 &a    0019F9EC
 
 result of  a.b1.func()  0019F9EC
 
*/

#include <limits>
#include <iostream>
#include <fstream>
class A;
class B;
class A
{
 public:
  B *func();
};
class B
{
 public:
  A a1;
  A a2;
};
B* A::func ()
{
 A B::* q;
 int *Offcet;
 B *Parent;
 q = &B::a1;
 Offcet=reinterpret_cast<int*>( &q );
 Parent = reinterpret_cast<B*>(reinterpret_cast<char*>(this) - *Offcet);
 return Parent;
}
int main ()
{
 B b;
 std::cout<<(void*)&b<<std::endl;
 std::cout<<(void*)b.a1.func()<<std::endl;
 std::cout<<(void*)b.a2.func()<<std::endl;
 return 0;
}

q = &B::a1;

void *parent;

#ifndef TARRAY_HPP_INCLUDED
#define TARRAY_HPP_INCLUDED
//=====================================================================================================================================================================================================
#include <malloc.h>
#include <limits>
//=====================================================================================================================================================================================================
template <typename TBase> class TArray
{
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 private:
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  size_t                                    Count;
  TBase                                    *Data;
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 public :
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
                                            TArray                           (                                                    );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
                                            TArray                           (const
                                                                              TArray                           &Original          );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
                                           ~TArray                           (                                                    );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  bool                                      ReSize                           (size_t                            Count             );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  bool                                      Empty                            (                                                    );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  bool                                      Filled                           (                                                    );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
                                            operator size_t                  (                                                    );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  TBase                                    &operator []                      (size_t                            Index             );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  TArray                                   &operator =                       (const
                                                                              TArray                           &Original          );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  bool                                      Addition                         (const
                                                                              TBase                            &s                 );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  bool                                      Addition                         (                                                    );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  TBase                                    &Last                             (                                                    );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  TArray                                    SubArray                         (size_t                            Start             ,
                                                                              size_t                            End               );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  bool                                      operator ==                      (const
                                                                              TArray                           &Compare           );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  bool                                      operator !=                      (const
                                                                              TArray                           &Compare           );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  size_t                                    Find                             (const
                                                                              TBase                            &s                 );
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
};
//=====================================================================================================================================================================================================
template <typename TBase>
TArray <TBase>        ::                    TArray                           (                                                    )
{
 Count=0;
 Data =NULL;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
TArray <TBase>        ::                    TArray                           (const
                                                                              TArray                           &Original          )
{
 TBase *Source;
 TBase *Target;
 if (Original.Count>0)
 {
  Data=(TBase*)malloc(_msize(Original.Data));
  if (Data!=NULL)
  {
   Count=_msize(Data)/sizeof(TBase);
   for (Source=Original.Data+Count-1, Target=Data+Count-1; Target>=Data; --Source, --Target)
   {
    new (Target) TBase;
    *Target=*Source;
   }
  }
  else
  {
   Count=0;
  }
 }
 else
 {
  Count=0;
  Data =NULL;
 }
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
TArray <TBase>        ::                   ~TArray                           (                                                    )
{
 TBase *p;
 if (Data!=NULL)
 {
  for (p=Data+Count-1; p>=Data; --p)
  {
   p->~TBase();
  }
  free(Data);
 }
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
bool
TArray <TBase>        ::                    ReSize                           (size_t                            Count             )
{
 TBase  *Buffer;
 TBase  *p;
 TBase  *End;
 size_t  NewCount;
 size_t  NewSize;
 NewSize=Count*sizeof(TBase);
 if ((NewSize/sizeof(TBase))==Count)
 {
  if (Count>this->Count)
  {
   Buffer=(TBase*)realloc((void*)Data, NewSize);
   if (Buffer!=NULL)
   {
    NewCount=_msize(Buffer)/sizeof(TBase);
    for (p=Buffer+NewCount-1, End=Buffer+this->Count; p>=End; --p)
    {
     new (p) TBase;
    }
    this->Count=NewCount;
          Data =Buffer;
   }
  }
  if (Count<this->Count)
  {
   if (Count>0)
   {
    for (p=Data+this->Count-1, End=Data+Count; p>=End; --p)
    {
     p->~TBase();
    }
    Buffer=(TBase*)realloc((void*)Data, NewSize);
    NewCount=_msize(Buffer)/sizeof(TBase);
    this->Count=NewCount;
          Data =Buffer;
   }
   else
   {
    for (p=Data+Count-1; p>=Data; --p)
    {
     p->~TBase();
    }
    free(Data);
    this->Count=0;
          Data =NULL;
   }
  }
 }
 return Count==this->Count;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
bool
TArray <TBase>        ::                    Empty                            (                                                    )
{
 return (Count==0);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
bool
TArray <TBase>        ::                    Filled                           (                                                    )
{
 return (Count!=0);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
TArray <TBase>        ::                    operator size_t                  (                                                    )
{
 return Count;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
TBase                                      &
TArray <TBase>        ::                    operator []                      (size_t                            Index             )
{
 return *(Data+Index);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
TArray <TBase>                             &
TArray <TBase>        ::                    operator =                       (const
                                                                              TArray                           &Original          )
{
 TBase  *Buffer;
 TBase  *Source;
 TBase  *Target;
 TBase  *p;
 TBase  *End;
 size_t  NewCount;
 size_t  NewSize;
 NewSize=Original.Count*sizeof(TBase);
 if (Original.Count>Count)
 {
  Buffer=(TBase*)realloc((void*)Data, NewSize);
  if (Buffer!=NULL)
  {
   NewCount=_msize(Buffer)/sizeof(TBase);
   for (p=Buffer+NewCount-1, End=Buffer+this->Count; p>=End; --p)
   {
    new (p) TBase;
   }
   for (Target=Buffer+NewCount-1, Source=Original.Data+NewCount-1; Target>=Buffer; --Target, --Source)
   {
    *Target=*Source;
   }
   this->Count=NewCount;
         Data =Buffer;
  }
  else
  {
   if (Data!=NULL)
   {
    for (Target=Buffer+Count-1, Source=Original.Data+Count-1; Target>=Buffer; --Target, --Source)
    {
     *Target=*Source;
    }
   }
  }
  return *this;
 }
 if (Original.Count>0)
 {
  if (Original.Count<Count)
  {
   for (p=Data+this->Count-1, End=Data+Original.Count; p>=End; --p)
   {
    p->~TBase();
   }
   Buffer=(TBase*)realloc((void*)Data, NewSize);
   for (Target=Buffer+Count-1, Source=Original.Data+Count-1; Target>=Buffer; --Target, --Source)
   {
    *Target=*Source;
   }
   this->Count=Count;
         Data =Buffer;
   return *this;
  }
  if (Original.Count==Count)
  {
   for (Target=Data+Count-1, Source=Original.Data+Count-1; Target>=Data; --Target, --Source)
   {
    *Target=*Source;
   }
   return *this;
  }
 }
 if (Original.Count==0)
 {
  if (Data!=NULL)
  {
   for (p=Data+this->Count-1; p>=Data; --p)
   {
    p->~TBase();
   }
   free(Data);
   this->Count=0;
         Data =NULL;
  }
  return *this;
 }
 return *this;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
bool
TArray <TBase>        ::                    Addition                         (const
                                                                              TBase                            &s                 )
{
 TBase  *Buffer;
 size_t  NewSize;
 size_t  NewCount;
 NewCount=Count+1;
 if (NewCount>0)
 {
  NewSize=NewCount*sizeof(TBase);
  if (((NewSize)/sizeof(TBase))==NewCount)
  {
   Buffer=(TBase*)realloc((void*)Data, NewSize);
   if (Buffer!=NULL)
   {
    if (_msize(Buffer)==NewSize)
    {
     new (Buffer+Count) TBase(s);
     Count=NewCount;
     Data =Buffer;
     return true;
    }
   }
  }
 }
 return false;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
bool
TArray <TBase>        ::                    Addition                         (                                                    )
{
 TBase  *Buffer;
 size_t  NewSize;
 size_t  NewCount;
 NewCount=Count+1;
 if (NewCount>0)
 {
  NewSize=NewCount*sizeof(TBase);
  if (((NewSize)/sizeof(TBase))==NewCount)
  {
   Buffer=(TBase*)realloc((void*)Data, NewSize);
   if (Buffer!=NULL)
   {
    if (_msize(Buffer)==NewSize)
    {
     new (Buffer+Count) TBase;
     Count=NewCount;
     Data =Buffer;
     return true;
    }
   }
  }
 }
 return false;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
TBase                                      &
TArray <TBase>        ::                    Last                             (                                                    )
{
 return *(Data+Count-1);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
TArray <TBase>
TArray <TBase>        ::                    SubArray                         (size_t                            Start             ,
                                                                              size_t                            End               )
{
 TArray <TBase>  Result;
 TBase          *Source;
 TBase          *Target;
 TBase          *Stop;
 Result.ReSize(End-Start+1);
 for (Source=Data+End, Target=Result.Data+End-Start, Stop=Data+Start; Source>=Stop; --Source, --Target)
 {
  *Target=*Source;
 }
 return Result;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
bool
TArray <TBase>        ::                    operator ==                      (const
                                                                              TArray                           &Compare           )
{
 TBase *Left;
 TBase *Right;
 if (Count==0)
 {
  return ((Compare.Count)==0);
 }
 if (Count!=Compare.Count)
 {
  return false;
 }
 for (Left=Data+Count-1, Right=Compare.Data+Count-1; Left>=Data; --Left, --Right)
 {
  if ((*Left)!=(*Right))
  {
   return false;
  }
 }
 return true;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
bool
TArray <TBase>        ::                    operator !=                      (const
                                                                              TArray                           &Compare           )
{
 TBase *Left;
 TBase *Right;
 if (Count==0)
 {
  return ((Compare.Count)!=0);
 }
 if (Count!=Compare.Count)
 {
  return true;
 }
 for (Left=Data+Count-1, Right=Compare.Data+Count-1; Left>=Data; --Left, --Right)
 {
  if ((*Left)!=(*Right))
  {
   return true;
  }
 }
 return false;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
template <typename TBase>
size_t
TArray <TBase>        ::                    Find                             (const
                                                                              TBase                            &s                 )
{
 TBase *p;
 for (p=Data+Count-1; p>=Data; --p)
 {
  if ((*p)==s)
  {
   return (p-Data);
  }
 }
 return std::numeric_limits<size_t>::max();
}
//=====================================================================================================================================================================================================
#endif // TARRAY_HPP_INCLUDED

Data[i].a.parent=&(Data[i]);

Array[2].a.parent=&(Array[34].a);