In the most normal situation, you can pretty much think of
struct A {
int i;
int foo() { return i; }
};
A a;
a.foo();
as
struct A {
int i;
};
int A_foo( A* this ) { return this->i; };
A a;
A_foo(&a);
(Starting to look like C, right?) So you would think the pointer &A::foo would just be the same as a normal function pointer. But there are a couple of complications: Multiple inheritance, and virtual functions.
So imagine we have:
struct A {int a;};
struct B {int b;};
struct C : A, B {int c;};
It might be laid out like this:
As you can see, if you want to point to the object with an A* or a C*, you point to the start, but if you want to point to it with a B* you have to point somewhere in the middle.
So if C inherits some member function from B and you want to point to it then call the function on a C*, it needs to know to shuffle the this pointer. That information needs to be stored somewhere. So it gets lumped in with the function pointer.
Now for every class that has virtual functions, the compiler creates a list of them called a virtual table. It then adds an extra pointer to this table to the class (vptr). So for this class structure:
struct A
{
int a;
virtual void foo(){};
};
struct B : A
{
int b;
virtual void foo(){};
virtual void bar(){};
};
The compiler might end up making it like this:
So a member function pointer to a virtual function actually needs to be an index into the virtual table.
So a member function pointer actually needs 1) possibly a function pointer, 2) possibly an adjustment of the this pointer, and 3) possibly a vtable index. To be consistent, every member function pointer needs to be capable of all of these. So that's 8 bytes for the pointer, 4 bytes for the adjustment, 4 bytes for the index, for 16 bytes total.
I believe this is something that actually varies a lot between compilers, and there are a lot of possible optimizations. Probably none actually implements it the way I've described.
For a lot of detail, see this (scroll to "Implementations of Member Function Pointers").
