我正在阅读 Bjarne 的论文:Multiple Inheritance for C++ .

在第 3 节第 370 页中，Bjarne 说“编译器将成员函数的调用转换为带有“额外”参数的“普通”函数调用；该“额外”参数是指向成员函数所针对的对象的指针叫做。”

我对这个额外的论点感到困惑。请看以下两个例子:

示例 1 :(第372页)

class A {
    int a;
    virtual void f(int);
    virtual void g(int);
    virtual void h(int);
};
class B : A {int b; void g(int); };
class C : B {int c; void h(int); };

-----------                vtbl:
+0:  vptr -------------->  -----------
+4:  a                     +0: A::f
+8:  b                     +4: B::g
+12: c                     +8: C::h
-----------                -----------  

C* pc;
pc->g(2)

(*(pc->vptr[1]))(pc, 2)

class A {...};
class B {...};
class C: A, B {...};

pc-->          ----------- 
                  A part
B:bf's this--> -----------  
                  B part
               ----------- 
                  C part
               -----------

C* pc;
pc->bf(2); //assume that bf is a member of B and that C has no member named bf.

bf__F1B((B*)((char*)pc+delta(B)), 2);

 -----------               
+0:  a                     
+4:  b                    
+8: c                     
-----------   

class A {...};
class B : A {...};
class C: B {...};
C* pc = new C();
B* pb = NULL;
pb = (B*)pc;
A* pa = NULL;
pa = (A*)pc;
cout << pc << pb << pa

class A {...};
class B {...};
class C: A, B {...};
C* pc = new C();
B* pb = NULL;
pb = (B*)pc;
A* pa = NULL;
pa = (A*)pc;

class A {virtual void f();};
class B {virtual void f(); virtual void g();};
class C: A, B {void f();};
A* pa = new C;
B* pb = new C;
C* pc = new C;
pa->f();
pb->f();
pc->f();
pc->g()

pc->g() ==> g__F1B((*B)((char*)pc+delta(B)))

struct vtbl_entry {
    void (*fct)();
    int  delta;
}

pb->f() // call of C::f:
register vtbl_entry* vt = &pb->vtbl[index(f)];
(*vt->fct)((B*)((char*)pb+vt->delta)) //vt->delta is a negative number I guess

最佳答案

Bjarne wrote: "Naturally, B::bf() expects a B* (to become its this pointer)." The compiler transforms the call into:

bf__F1B((B*)((char*)pc+delta(B)), 2);

Why here we need a B* pointer to be the this?

(1) When it's a linear chain derivation (example 1), why the C object can be expected to be at the same address as the B and in turn A sub-objects? There is no problem to use a C* pointer to access class B's members inside the function B::g in example 1? For example, we want to access the member b, what will happen in runtime? *(pc+8)?

[[[A fields...]B-specific-fields....]C-specific-fields...]
 ^
 |--- A, B & C all start at the same address

(2) Why can we use the same memory layout (linear chain derivation) for the multiple-inheritance? Assuming in example 2, class A, B, C have exactly the same members as the example 1. A: int a and f; B: int b and bf (or call it g); C: int c and h. Why not just use the memory layout like:

-----------               
+0:  a                     
+4:  b                    
+8: c                     
-----------   

[[A fields...][B fields....]C-specific-fields...]
 ^             ^
 \ A&C start   \ B starts

关于c++ - 编译器关于此指针、虚函数和多重继承的详细信息，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30747633/