Pointer to members from Bruce Eckel's Thinking in C++

Question

The following is a paragraph from Bruce Eckel's Thinking in C++ (volume 1, 2nd edition, chapter 11) under the heading "Pointers to members":

…a pointer needs an address, but there is no "address" inside the class; selecting the member of class means offsetting into that class. You cannot produce an actual address untill you combine that offset with the starting address of particular object. The syntax of pointer to member require you select an object at the same time you're dereferencing the pointer to member.

What does this quote mean? I am trying to do something like:

&(objectname.member_variable)

I get an actual address, something like 0x22f14, but this offset means how far it is from the starting address?

Answer 1

I think that &(foo.bar) is just a regular pointer to a variable. By saying "pointer to member" we mean something like &(FooClass::bar), without specyfying any objects! Note, this value may be actually computed at compile-time and may be used e.g. in templates.

Member pointers have really weird syntax.

Try running the following code:

#include <stdio.h>

class FooClass {
  public:
    int bar;
    int bar2;
    FooClass() : bar(0), bar2(0) {}
};

int main() {

  //Showing what member pointers actually hold:
  int FooClass::* barPtr=&FooClass::bar;
  int FooClass::* bar2Ptr=&FooClass::bar2;
  printf("barPtr=%p\nbar2Ptr=%p\n",barPtr,bar2Ptr);

  //Showing how to use them:
  FooClass foo;
  foo.*bar2Ptr=42;
  printf("foo={%d,%d}\n",foo.bar,foo.bar2);
}

You will get the output:

barPtr=0x0
bar2Ptr=0x4
foo={0,42}

As you can see, both values hold an offset of the member from the beginning of the class. They can be computed, even if you don't know on which object you are working.

But if you want to dereference them, you have to provide an object - that's what the .* operator does.

Answer 2

Yes, in this case the term offset means how far that particular member is stored in memory from the first member of that class (which is the object location).

The value you get as result is the memory position for member *member_variable*. Just for visualization purpose, if you would like to know the offset in bytes you could do something like this:

std::cout << reinterpret_cast<char *>(&(objectname.member_variable)) - reinterpret_cast<char *>(&objectname);