There are probably several strategies to realize this, here is one:
A vtable (Virtual Table) is a compile-time-constant struct with function pointers. (All values are known at compile-time.)
(You can call the pointer to a vtable an "interface", if you want.)
An OOP-class in a language without any ability of inheritance is a struct that contains a const pointer to its vtable as first member-variable.
This pointer is used to exactly identify the type of the object, and with multi-inheritance the aspect/view (as what casted?) on that object.
If you want to have multi-inheritance, then you need to be able to (static_)cast the pointer to a derived class to its parent class, correcting the byte-address on the fly. This could be realized with one virtual function or (better) with a signed offset value stored in the vtable.
A (dynamic_)cast from the pointer to a parent class to the pointer to a derived class either implies a lookup in a probably large datastructure (array,hashtable,whatever) or is realized via one virtual function, too.
Each call to a function from the vtable needs the object-pointer to be casted to the type, that is appropriate for the function. This might be done either by the caller, reading the signed offset (correspoinding to the function) from the vtable, or by the callee, which then is only a proxy of the original function.
In some languages (especially functional languages) you can define references to (untyped) objects that instanciate a list of interfaces/typeclasses, valid on that object. Such a reference contains one pointer to the base-object and a list of pointers to the relevant vtables.