c++ - 指向成员函数的指针如何工作？

Question

我知道普通函数指针包含要指向的函数的起始地址，因此当使用普通函数指针时，我们只需跳转到存储的地址即可。但是指向对象成员函数的指针包含什么？

考虑:

class A
{
public:
    int func1(int v) {
        std::cout << "fun1";
        return v;
    }
    virtual int func2(int v) {
        std::cout << "fun2";
        return v;
    }
};

int main(int argc, char** argv)
{
    A a;
    int (A::*pf)(int a) = argc > 2 ? &A::func1 : &A::func2;
    static_assert(sizeof(pf) == (sizeof(void*), "Unexpected function size");
    return (a.*pf)(argc);
}

在上述程序中，函数指针可以从虚拟函数(需要通过vtable访问)或普通类成员(通过隐式 this作为第一个参数实现为普通函数)中获取其值。

那么，在指向成员函数的指针中存储的值是多少？编译器如何使事情按预期工作？

Answer 1

当然，这取决于编译器和目标体系结构，并且有多种方法可以实现。但是，我将描述它如何在我最常使用的系统上(在Linux x86_64上使用g++)工作。
g++遵循Itanium C++ ABI，它描述了许多架构可以在幕后实现各种C++功能(包括虚拟功能)的一种方式的许多细节。
ABI在第2.3节中说了关于成员函数的指针:

A pointer to member function is a pair as follows:

   ptr:

For a non-virtual function, this field is a simple function pointer. ... For a virtual function, it is 1 plus the virtual table offset (in bytes) of the function, represented as a ptrdiff_t. The value zero represents a NULL pointer, independent of the adjustment field value below.

   adj:

The required adjustment to this, represented as a ptrdiff_t.

It has the size, data size, and alignment of a class containing those two members, in that order.

虚拟函数的+1到ptr有助于检测该函数是否是虚拟的，因为在大多数平台上，所有函数指针值和vtable偏移量都是偶数。它还可以确保空成员函数指针具有与任何有效成员函数指针不同的值。
您的类 A的vtable / vptr设置将类似于以下C代码:

struct A__virt_funcs {
    int (*func2)(A*, int);
};

struct A__vtable {
    ptrdiff_t offset_to_top;
    const std__typeinfo* typeinfo;
    struct A__virt_funcs funcs;
};

struct A {
    const struct A__virt_funcs* vptr;
};

int A__func1(struct A*, int v) {
    std__operator__ltlt(&std__cout, "fun1");
    return v;
}

int A__func2(struct A*, int v) {
    std__operator__ltlt(&std__cout, "fun2");
    return v;
}

extern const std__typeinfo A__typeinfo;

const struct A__vtable vt_for_A = { 0, &A__typeinfo, { &A__func2 } };

void A__initialize(A* a) {
    a->vptr = &vt_for_A.funcs;
}

(是的，实名处理方案需要对函数参数类型进行某些操作以允许重载，并且还需要做更多的事情，因为涉及的 operator<<实际上是函数模板的一种特殊化。但这不重要。)
现在，让我们看看为您的 main()(带有 -O0 -fno-stack-protector选项)获得的程序集。我的评论已添加。

Dump of assembler code for function main:
     // Standard stack adjustment for function setup.
   0x00000000004007e6 <+0>: push   %rbp
   0x00000000004007e7 <+1>: mov    %rsp,%rbp
   0x00000000004007ea <+4>: push   %rbx
   0x00000000004007eb <+5>: sub    $0x38,%rsp
     // Put argc in the stack at %rbp-0x34.
   0x00000000004007ef <+9>: mov    %edi,-0x34(%rbp)
     // Put argv in the stack at %rbp-0x40.
   0x00000000004007f2 <+12>:    mov    %rsi,-0x40(%rbp)
     // Construct "a" on the stack at %rbp-0x20.
     // 0x4009c0 is &vt_for_A.funcs.
   0x00000000004007f6 <+16>:    mov    $0x4009c0,%esi
   0x00000000004007fb <+21>:    mov    %rsi,-0x20(%rbp)
     // Check if argc is more than 2.
     // In both cases, "pf" will be on the stack at %rbp-0x30.
   0x00000000004007ff <+25>:    cmpl   $0x2,-0x34(%rbp)
   0x0000000000400803 <+29>:    jle    0x400819 <main+51>
     // if (argc <= 2) {
     //   Initialize pf to { &A__func2, 0 }.
   0x0000000000400805 <+31>:    mov    $0x4008ce,%ecx
   0x000000000040080a <+36>:    mov    $0x0,%ebx
   0x000000000040080f <+41>:    mov    %rcx,-0x30(%rbp)
   0x0000000000400813 <+45>:    mov    %rbx,-0x28(%rbp)
   0x0000000000400817 <+49>:    jmp    0x40082b <main+69>
     // } else { [argc > 2]
     //   Initialize pf to { 1, 0 }.
   0x0000000000400819 <+51>:    mov    $0x1,%eax
   0x000000000040081e <+56>:    mov    $0x0,%edx
   0x0000000000400823 <+61>:    mov    %rax,-0x30(%rbp)
   0x0000000000400827 <+65>:    mov    %rdx,-0x28(%rbp)
     // }
     // Test whether pf.ptr is even or odd:
   0x000000000040082b <+69>:    mov    -0x30(%rbp),%rax
   0x000000000040082f <+73>:    and    $0x1,%eax
   0x0000000000400832 <+76>:    test   %rax,%rax
   0x0000000000400835 <+79>:    jne    0x40083d <main+87>
     // int (*funcaddr)(A*, int); [will be in %rax]
     // if (is_even(pf.ptr)) {
     //   Just do:
     //   funcaddr = pf.ptr;
   0x0000000000400837 <+81>:    mov    -0x30(%rbp),%rax
   0x000000000040083b <+85>:    jmp    0x40085c <main+118>
     // } else { [is_odd(pf.ptr)]
     //   Compute A* a2 = (A*)((char*)&a + pf.adj); [in %rax]
   0x000000000040083d <+87>:    mov    -0x28(%rbp),%rax
   0x0000000000400841 <+91>:    mov    %rax,%rdx
   0x0000000000400844 <+94>:    lea    -0x20(%rbp),%rax
   0x0000000000400848 <+98>:    add    %rdx,%rax
     //   Compute funcaddr =
     //     (int(*)(A*,int)) (((char*)(a2->vptr))[pf.ptr-1]);
   0x000000000040084b <+101>:   mov    (%rax),%rax
   0x000000000040084e <+104>:   mov    -0x30(%rbp),%rdx
   0x0000000000400852 <+108>:   sub    $0x1,%rdx
   0x0000000000400856 <+112>:   add    %rdx,%rax
   0x0000000000400859 <+115>:   mov    (%rax),%rax
     // }
     // Compute A* a3 = (A*)((char*)&a + pf.adj); [in %rcx]
   0x000000000040085c <+118>:   mov    -0x28(%rbp),%rdx
   0x0000000000400860 <+122>:   mov    %rdx,%rcx
   0x0000000000400863 <+125>:   lea    -0x20(%rbp),%rdx
   0x0000000000400867 <+129>:   add    %rdx,%rcx
     // Call int r = (*funcaddr)(a3, argc);
   0x000000000040086a <+132>:   mov    -0x34(%rbp),%edx
   0x000000000040086d <+135>:   mov    %edx,%esi
   0x000000000040086f <+137>:   mov    %rcx,%rdi
   0x0000000000400872 <+140>:   callq  *%rax
     // Standard stack cleanup for function exit.
   0x0000000000400874 <+142>:   add    $0x38,%rsp
   0x0000000000400878 <+146>:   pop    %rbx
   0x0000000000400879 <+147>:   pop    %rbp
     // Return r.
   0x000000000040087a <+148>:   retq   
End of assembler dump.

但是，成员函数指针的 adj值如何处理？程序集在执行vtable查找之前以及在调用函数之前将其添加到 a的地址中，无论该函数是否是虚拟的。但是 main中的两种情况都将其设置为零，因此我们还没有真正看到它在起作用。
当我们有多个继承时，就会传入 adj值。现在假设我们有:

class B
{
public:
    virtual void func3() {}
    int n;
};

class C : public B, public A
{
public:
    int func4(int v) { return v; }
    int func2(int v) override { return v; }
};

类型为 C的对象的布局包含 B子对象(包含另一个vptr和 int)，然后是 A子对象。因此， A中包含的 C的地址与 C本身的地址不同。
如您所知，任何时间代码都会隐式或显式地将(非null) C*指针转换为 A*指针，C++编译器通过在地址值中添加正确的偏移量来解决这一差异。 C++还允许将 A成员函数的指针转换为 C成员函数的指针(因为 A的任何成员也是 C的成员)，并且在发生这种情况时(对于非null成员函数指针)，需要进行类似的偏移量调整。因此，如果我们有:

int (A::*pf1)(int) = &A::func1;
int (C::*pf2)(int) = pf1;

在幕后成员函数指针中的值将是 pf1 = { &A__func1, 0 };和 pf2 = { &A__func1, offset_A_in_C };。
然后，如果我们有

C c;
int n = (c.*pf2)(3);

编译器将通过向地址 pf2.adj中添加偏移量 &c来找到隐式的“this”参数，从而实现对成员函数指针的调用，这是很好的，因为这将是 A*期望的有效 A__func1值。
对于虚拟函数调用，情况也一样，除了反汇编转储所示，需要偏移量以查找隐式的“this”参数并查找包含实际功能代码地址的vptr。虚拟情况增加了一种扭曲，但普通的虚拟调用和使用指向成员函数的指针的调用都需要这种情况:虚拟函数 func2将使用 A*“this”参数进行调用，因为这是原始覆盖声明的地方是，并且编译器通常将无法知道“this”参数是否实际上是任何其他类型。但是覆盖 C::func2的定义需要 C*“this”参数。因此，当最派生的类型是 C时， A子对象内的vptr将指向一个vtable，该表的入口不指向 C::func2本身的代码，而是一个微小的“thunk”函数，该函数除了从odt中减去 offset_A_in_C外什么也不做“this”参数，然后将控制权传递给实际的 C::func2。