Why the size of a pointer to a function is different from the size of a pointer to a member function?

Question

Isn't a pointer just an address? Or I'm missing something?

I tested with several types of pointers:

• pointers to any variables is the same (8B on my platform)
• pointers to functions are the same size, as pointers to variables (8B again)
• pointers to functions with different parameters - still the same (8B)

BUT pointers to member functions are bigger - 16B on my platform.

Three things:

1. Why are pointers to member functions bigger? What more information do they need?
2. As far as I know, the standard says nothing about the size of a pointer, except that void* must be able to "contain" any pointer type. In other words, any pointer must be able to be casted to void*, right? If so, then why sizeof( void* ) is 8, while sizeof a pointer to member function is 16?
3. Are there any other examples for pointers, that are with different size (I mean, for standard platforms, not some rare and special ones)?

Answer 1

EDIT: So I noticed I'm still getting votes on this months later, even though my original answer is bad and misleading (I can't even remember what I was thinking at the time, and it doesn't make a lot of sense!) so I thought I'd try and clarify the situation, as people must still be getting here through search.

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").