so I believe I understand polymorphism with single inheritance, where say you have classes Dog and Cat inherit from an interface Animal and Animal has a Speak and Walk function so then you generate v tables for Dog and Cat, both having a function pointer to their respective Speak and Walk functions, and if I’m calling a general one of those functions for a general Animal, assembly will grab the first data member of the Animal which is a pointer to the v table, dereference it, then add the correct offset to get the correct function pointer, then call said function at the memory address.

所以我相信我理解单继承的多态，假设你有Dog和Cat类，Animal继承自一个接口Animal和Animal有一个Speech和Walk函数，所以你为Dog和Cat生成v表，这两个表都有一个指向它们各自的Speech和Walk函数的函数指针，如果我为一般的Animal调用这些函数中的一个通用函数，汇编将获取Animal的第一个数据成员，它是指向v表的指针，取消对它的引用，然后添加正确的偏移量以获得正确的函数指针，然后在内存地址调用所述函数。

So my question is how would this work for multiple inheritance. So for the example, I will do Dog and Cat inheriting from interfaces Animal and Colorable: Animal will have functions Speak and Walk, and Colorable will have GetColor and SetColor. Would Dog have have a v table to Animal functions and then a v table to Colorable functions? Would that mean that every Colorable class would have memory padding so that way its v table is the second member so that you can do polymorphism with Colorable? Or would you have a triple pointer pointing to a table of v table pointers so that you only have class instances of the memory padding as opposed to object instances? Wouldn’t dereferencing a triple pointer be slow?

所以我的问题是，这将如何适用于多重继承。例如，我将从接口Animal和Colorable继承Dog和Cat：Animal将具有函数Speak和Walk，Colorable将具有GetColor和SetColor。Dog会有一个v表给Animal函数，然后有一个v表给Colorable函数吗？这是否意味着每个Colorable类都有内存填充，这样它的v表就是第二个成员，这样你就可以用Colorable做多态了？或者你会有一个三重指针指向一个v表指针的表，这样你就只有内存填充的类实例，而不是对象实例？解引用一个三重指针不会很慢吗？

Is there another memory schema that I’m not considering? I haven’t found many good resources on this.

有没有其他我没有考虑过的记忆模式？我在这方面没有找到很多好的资源。

I know C#, Java, Rust, etc. supports polymorphism with multiple inheritance, so I feel like this is a solved thing.

我知道C#、Java、Rust等支持多重继承的多态，所以我觉得这是一个可以解决的问题。

I have tried searching on YouTube and stack overflow and Google, none of which have given me good results. I did find a page regarding Java doing multiple inheritance but to me it was kind of cryptic and hard to understand.

我试着在YouTube、Stack Overflow和谷歌上搜索，但都没有给我带来好的结果。我确实找到了一个关于Java执行多重继承的页面，但对我来说，它有点神秘，很难理解。

Edit:
To add clarification, I’m looking specifically for single layered inheritance, like Rust’s trait syntax. Regarding C# and Java multiple inheritance, I am referring to the ability to use multiple interfaces for an object and be able to use said interface as a type for static polymorphism. Rust allows for implementing multiple traits.

编辑：为了补充说明，我专门寻找单层继承，比如Rust的特征语法。关于C#和Java多重继承，我指的是对一个对象使用多个接口的能力，并能够将该接口用作静态多态的类型。锈病允许实现多种特征。

None of the languages you say implement inheritance in the way you describe. You are describing C++ - it's in C++ you have a pointer to vtable at the beginning of a class.

您所说的语言都没有以您所描述的方式实现继承。您描述的是C++--在C++中，在类的开头有一个指向vtable的指针。

In C++, the first base class gets merged with the derived: the vtable pointer in the beginning of the Dog is also a vtable pointer for the inscribed Animal base class (if Animal is first). The vtable would start with Animal virtual functions (Speak, Walk), then other base classes functions (GetColor, SetColor), then other virtual finctions of Dog, if any.

在C++中，第一个基类与派生的合并：Dog开头的vtable指针也是内切的Animal基类的vtable指针(如果Animal是第一个)。Vtable将从Animal虚拟函数(Speech、Walk)开始，然后是其他基类函数(GetColor、SetColor)，然后是Dog的其他虚拟函数(如果有的话)。

All other base classes will have a different vtable. That means the inscribed Colorable vtable pointer will point to a different vtable of Dog - the one that has GetColor and SetColor first. Moreover, those virtual functions will not be the same as the ones in the main vtable! They would be a special versions, that correct the pointer first (to point on Dog instance, instead of the inscribed Colorable instance).

所有其他基类都将具有不同的vtable。这意味着内嵌的可着色vtable指针将指向Dog的另一个vtable-首先具有GetColor和SetColor的那个vtable。此外，这些虚拟函数将不会与主vtable中的函数相同！它们将是一个特殊的版本，首先更正指针(指向Dog实例，而不是内嵌的可着色实例)。

In Java, there is a vtable for each base interface, and the runtime does a search in the list of interfaces to find a correct one. It is pretty much the same in C#, with minor differences. The JIT-compiler can optimize that, if needed.

在Java中，每个基本接口都有一个vtable，运行时在接口列表中进行搜索以找到正确的接口。这在C#中基本相同，只是有一些细微的不同。如果需要，JIT编译器可以对其进行优化。

In Rust, there are no pointers to vtable inside the "classes" at all. Instead, Rust uses "fat pointers" for the interfaces themselves - references to the interface are double sized, because they contain two pointers: one for the object, one for the vtable. The pointer to the vtable is only produced when you convert an object to a &dyn Interface type - not before. The pointer points to the correct position inside the vtable, so the current interface functions will appear first:

在Rust中，在“类”中根本没有指向vtable的指针。相反，Rust对接口本身使用“胖指针”--对接口的引用是双倍大小的，因为它们包含两个指针：一个用于对象，一个用于vtable。指向vtable的指针仅在您将对象转换为&dyn Interface类型时才会产生-而不是在此之前。指针指向vtable内的正确位置，因此当前接口函数将首先出现：

• &dyn Animal will be equal {&Dog, &Dog_vtable + 0},


• &dyn Colorable will be equal {&Dog, &Dog_vtable + 16}, etc