How about instead, making a pointer "two pointers".

Yes, I think that could be done, theoretically — there are a lot of ways C++ could be implemented. These choices are all trade-offs of one thing for another; though, there are lots of considerations to be made in such a change.

C++ avoids search across multiple inheritance parent classes by capitalizing on the point of conversion (from the concrete class to the (abstract) base). Other languages choose instead to search for an interface in the vtable of the concrete class (and instead do nothing at point of conversion), but pretty sure C++ could do that, too, if they wanted to, don't think there's any strict rule as to how it must be implemented.  (FYI, Doing nothing at point of conversion tends to be somewhat friendlier to garbage collection, another reason this tends to be favored by C# and Java.)

However, C++ allows instance members in (abstract) base classes, whereas C# and Java don't support instance members for interfaces.  This makes things a bit trickier for C++, since it has to know about data slots in the object as well as function slots in the vtable.  Perhaps due to this, I think, C++'s usually settle on adjusting the object pointer at point of conversion, rather than searching for data slots and searching for virtual function slots.

Note that a single object implementing 5 different interfaces is, IMHO, overrated.  You might find composition better for many scenarios, meaning that you would create several cooperating classes, each class implementing only one interface.   (Also note that the overhead you're describing only happens on the second parent class, not the first, as the subclass and its first base can share a vtable pointer.)

In any case, the overhead is minimal unless you're going to create a huge amount of these objects.  Usually, objects created in great quantities can be optimized in various ways, such as the (albeit complex) flyweight pattern.

How about instead, making a pointer "two pointers".

Yes, I think that could be done, theoretically — there are a lot of ways C++ could be implemented. These choices are all trade-offs of one thing for another; though, there are lots of considerations to be made in such an implementation.

C++ avoids search across multiple inheritance parent classes by capitalizing on the point of conversion (from the concrete class to the (abstract) base). Other languages choose instead to search for an interface in the vtable of the concrete class (and instead do nothing at point of conversion), but pretty sure C++ could do that, too, if they wanted to, don't think there's any strict rule as to how it must be implemented.  (FYI, Doing nothing at point of conversion tends to be somewhat friendlier to garbage collection, another reason this tends to be favored by C# and Java.)

However, C++ allows instance fields in (abstract) base classes, whereas C# and Java don't support instance fields for interfaces.  This makes things a bit trickier for C++, since it has to know about data slots in the object as well as function slots in the vtable.  Perhaps due to this, I think, C++'s usually settle on adjusting the object pointer at point of conversion, rather than searching for data slots and searching for virtual function slots.

Note that a single object implementing 5 different interfaces is, IMHO, overrated.  You might find composition better for many scenarios, meaning that you would create several cooperating classes, each class implementing only one interface. 

(Also note that the overhead you're describing only happens on the second parent class, not the first, as the subclass and its first base can share a vtable pointer.)

In any case, the overhead is minimal unless you're going to create a huge amount of these objects.  Usually, objects created in great quantities can be optimized in various ways, such as the (albeit complex) flyweight pattern.

How about instead, making a pointer "two pointers".

Yes, I think that could be done — there are a lot of ways C++ could be implemented. These choices are all trade-offs of one thing for another.

C++ avoids search across multiple inheritance parent classes by capitalizing on the point of conversion (from the concrete class to the abstract base). Other languages choose instead to search for an interface in the vtable of the concrete class (and instead doing nothing at point of conversion), but pretty sure C++ could do that, too, if they wanted to, don't think there's any strict rule as to how it must be implemented.  (FYI, Doing nothing at point of conversion tends to be somewhat friendlier to garbage collection.)

However, C++ allows instance members in abstract classes, whereas C# and Java don't support instance members for interfaces.  This makes things a bit trickier for C++, since it has to know about data slots in the object as well as function slots in the vtable.  Perhaps due to this, I think, C++'s usually settle on adjusting the object pointer at point of conversion, rather than searching for data slots and searching for virtual function slots.

Note that a single object implementing 5 different interfaces is, IMHO, overrated.  You might find composition better for many scenarios, meaning that you would create several cooperating classes, each class implementing only one interface.  (Also note that the overhead you're describing only happens on the second parent class, not the first, as the subclass and its first base can share a vtable pointer.)

How about instead, making a pointer "two pointers".

Yes, I think that could be done, theoretically — there are a lot of ways C++ could be implemented. These choices are all trade-offs of one thing for another; though, there are lots of considerations to be made in such a change.

C++ avoids search across multiple inheritance parent classes by capitalizing on the point of conversion (from the concrete class to the (abstract) base). Other languages choose instead to search for an interface in the vtable of the concrete class (and instead do nothing at point of conversion), but pretty sure C++ could do that, too, if they wanted to, don't think there's any strict rule as to how it must be implemented.  (FYI, Doing nothing at point of conversion tends to be somewhat friendlier to garbage collection, another reason this tends to be favored by C# and Java.)

However, C++ allows instance members in (abstract) base classes, whereas C# and Java don't support instance members for interfaces.  This makes things a bit trickier for C++, since it has to know about data slots in the object as well as function slots in the vtable.  Perhaps due to this, I think, C++'s usually settle on adjusting the object pointer at point of conversion, rather than searching for data slots and searching for virtual function slots.

Note that a single object implementing 5 different interfaces is, IMHO, overrated.  You might find composition better for many scenarios, meaning that you would create several cooperating classes, each class implementing only one interface.  (Also note that the overhead you're describing only happens on the second parent class, not the first, as the subclass and its first base can share a vtable pointer.)

In any case, the overhead is minimal unless you're going to create a huge amount of these objects.  Usually, objects created in great quantities can be optimized in various ways, such as the (albeit complex) flyweight pattern.