Getting a class/struct object from the member pointer

Question

I have C++ structure as

struct myStruct {
    int a;
    int b;
    int c;
}; 

myStruct b;
int *ptr = &b.c;

How can I get myStruct object back from ptr?

(I know I can do this using pointer arithmatic like container_Of() in C. Basically something like

reinterpret_cast<myStruct*>(reinterpret_cast<char *>(ptr) - offsetof(myStruct, c));

I am asking if there is any recommended/elegant way?)

Answer 1

There's certainly no recommended way, as doing this is definitely not recommended at all in C++. This is one of those questions where the correct answer has to be "Don't do that!"

The whole reason for using C++ instead of C is that you want to encapsulate the structure of data inside classes with sensible operations defined on them, instead of allowing the whole program to have knowledge of the internal layout of data structures.

That said, the offsetof technique you describe will work on plain old data objects, because they are no different to C structs.

Answer 2

Because ptr has no knowledge of its overlaying struct, I don't think there's an elegant way of getting back to myStruct. I just recommend to not do this!

Answer 3

Your reinterpret_cast solution is the standard way to achieve what you want. The reason that it must involve at least one casts is that the operation that you want to perform is inherently unsafe. Obviously, not every pointer to an int is a pointer to the third member of a myStruct so there can't be a simple type-safe way to perform the conversion.

Answer 4

Your text & example use a POD struct; your title talks about classes as well, however. The answer below won't work for non-POD types.

For POD types, check out the "offsetof" macro....

Find the offset, use that & pointer arithmetic to back up say a char * the base.

Answer 5

You can maybe use the fact, that when you make a cast from a pointer to a base class, that is not the only base class, the compiler will adjust the pointer so that it will point to the beginning of the super class. Therefore, if your "c" member would exist at the beginning of some base class, you could do a trick like:

struct myStructBase1 { int a; };
struct myStructBase2 { int b; };
struct myStructBase3 { int c; };

struct myStruct : public myStructBase1,myStructBase2,myStructBase3 {
    int d;
};

int main() {
    myStruct my;

    int * bptr = &my.b;
    int * cptr = &my.c;
    // The only dirty part in the code...
    myStructBase2 * base2ptr = reinterpret_cast<myStructBase2*> (bptr);
    myStructBase3 * base3ptr = reinterpret_cast<myStructBase3*> (cptr);

    // In each (myStruct*) cast the pointers are adjusted to point to the super class.
    cout << &my << endl <<
            (myStruct*) base2ptr << endl <<
            (myStruct*) base3ptr << endl;
    return 0;
}
// Output:
// 0xbfbc779c
// 0xbfbc779c
// 0xbfbc779c

The requirement for this to work is: if a member is the first member in its class, then its address in a object is equal to address of the object (of that class). I'm not sure if this is true.

EDIT: it should hold when the wrapper-base classes will be PODs. After following modifications:

struct myStructBase1 { int a; virtual void g() {} };
struct myStructBase2 { int b; virtual void f() {} };
struct myStructBase3 { int c;  };
struct myStruct : public myStructBase1,myStructBase2,myStructBase3 {
    int d;
    virtual void h() {}
};

The output is:

0xbfa305f4
0xbfa305f8
0xbfa305f4

For the c member, the constraint still holds. So generally the answer is: yes, there is an alternative way. However, defining a base class for each "reversible"-member is probably not wise way..