指向具有继承类型的类数据成员的指针

Question

I'd like to use a pointer to a class data member that has an inherited type. The code is pretty straightforward, I have an object (A) with a data member which class (Integer) inherits another class (Type), and I'd like to create a pointer to this data member using the parent class (Type*) instead of the base class (Integer) :

class Type
{
public:
    Type() {}
};

class Integer : public Type
{
public:
    Integer() : Type() {}
    int value;
};

class A
{
public:
    A() { p_value.value = 0; };
    Integer p_value;
};

int main()
{
    Type* aType = &A::p_value;
    return 0;
}

the code on ideone

I have a compilation error:

error line: Type* aType = &A::p_value;
error: cannot convert 'Integer A::*' to 'Type*' in initialization

After a lot of fiddling with the code I couldn't make it work, what am I doing wrong ?

Answer 1

Basically types of pointers aren't matching. &A::p_value is of type A::*Integer (or Integer A::* as compiler nicely states), while Type* is... just Type* .

Former ( A::*Integer ) is a pointer to member and can be used like this:

A a1;
A* a2 = new A; 
A::*Integer a_member = &A::p_value;
a1.*a_member = 1;
a1->*a_member = 2;
// now a.p_value == 1 a->p_value == 2

Meanwhile Type* is just pointer to Type object - since Type class hierarchy is separate from A class hierarchy no casting between classes make sense. And here you want to cast from pointer to member to pointer to class. You most likely wanted to to something like this:

int main()
{
    A a;
    Type* aType = &a.p_value;
    return 0;
}

Difference lies in what they do. Pointer to class will look up in memory beginning of your object, then use information about where in this object particular member/virtual function pointer lies, go there and return value. We use them to obtain data or call virtual method basing on object's address.

In the other hand pointer to member only knows the difference between beginning of object's memory and sought data position. So you need to have both object's address and the delta to figure out location of the data:

(object_by_value).*(pointer_to_member);
(object_by_pointer)->*(pointer_to_member);

By the way they work you can understand that casting one into another will only produce garbage and compiler saves you from that mistake with a warning:

cannot convert 'Integer A::*' to 'Type*' in initialization