我对vptr和内存中对象的表示有点困惑，希望你能帮助我更好地理解这个问题。
考虑类B继承自A，两个类都定义了虚函数f()。根据我的理解，类B的一个对象在内存中的表示形式如下:[ vptr | A | B ]，并且vptr所指向的vtbl包含。我也理解将对象从B转换为A除了忽略对象结尾的B部分之外并不做任何事情。这是正确的吗?这种行为不会出现问题吗? 我们希望类型为A的对象执行方法而不是方法。
系统中是否有与类数量相同的vtable？
继承两个或更多类的类的vtable看起来会是什么样子？C类的对象在内存中的表示形式是什么？
与第3题相同，但使用虚拟继承。
A more correct way to depict internal representation of the object is:
| vptr | ======= | ======= | <-- your object
|----A----| |
|---------B---------|
B contains its base class A, it just adds a couple of his own members after its end.
Casting from B* to A* indeed does nothing, it returns the same pointer, and vptr remains the same. But, in a nutshell, virtual functions are not always called via vtable. Sometimes they're called just like the other functions.
Here's more detailed explanation. You should distinguish two ways of calling member function:
A a, *aptr;
a.func(); // the call to A::func() is precompiled!
aptr->A::func(); // ditto
aptr->func(); // calls virtual function through vtable.
// It may be a call to A::func() or B::func().
The thing is that it's known at compile time how the function will be called: via vtable or just will be a usual call. And the thing is that the type of a casting expression is known at compile time, and therefore the compiler chooses the right function at compile time.
B b, *bptr;
static_cast<A>(b)::func(); //calls A::func, because the type
// of static_cast<A>(b) is A!
It doesn't even look inside vtable in this case!
Generally, no. A class can have several vtables if it inherits from several bases, each having its own vtable. Such set of virtual tables forms a "virtual table group" (see pt. 3).
Class also needs a set of construction vtables, to correctly distpatch virtual functions when constructing bases of a complex object. You can read further in the standard I linked.
Here's an example. Assume C inherits from A and B, each class defining virtual void func(), as well as a,b or c virtual function relevant to its name.
The C will have a vtable group of two vtables. It will share one vtable with A (the vtable where the own functions of the current class go is called "primary"), and a vtable for B will be appended:
| C::func() | a() | c() || C::func() | b() |
|---- vtable for A ----| |---- vtable for B ----|
|--- "primary virtual table" --||- "secondary vtable" -|
|-------------- virtual table group for C -------------|
The representation of object in memory will look nearly the same way its vtable looks like. Just add a vptr before every vtable in a group, and you'll have a rough estimate how the data are laid out inside the object. You may read about it in the relevant section of the GCC binary standard.
Virtual bases (some of them) are laid out at the end of vtable group. This is done because each class should have only one virtual base, and if they were mingled with "usual" vtables, then compiler couldn't re-use parts of constructed vtables to making those of derived classes. This would lead to computing unnecessary offsets and would decrease performance.
Due to such a placement, virtual bases also introduce into their vtables additional elements: vcall offset (to get address of a final overrider when jumping from the pointer to a virtual base inside a complete object to the beginning of the class that overrides the virtual function) for each virtual function defined there. Also each virtual base adds vbase offsets, which are inserted into vtable of the derived class; they allow to find where the data of the virtual base begin (it can't be precompiled since the actual address depends on the hierarchy: virtual bases are at the end of object, and the shift from beginning varies depending on how many non-virtual classes the current class inherits.).
汪，我希望我没有引入太多不必要的复杂性。无论如何，您可以参考原始标准或自己编译器的任何文档。
我建议阅读Multiple Inheritance Considered Useful，这是一篇长文，但它通过详细解释C++中继承的工作原理使事情变得更加清晰（图像链接不起作用，但它们在页面底部可用）。
(A)b不是一个指针转换，你正在构造另一个对象。 - curiousguy