Multiple Inheritance is just what the name says and not the same as a language that utilises interfaces and uses single inheritance. Where a language like C# can inherit, the model is not multiple inheritance like C++. With C# as an example, you can inherit from a single class, abstract or fully implemented. You can also implement as many interfaces as you want but this is where an interface is different from an abstract class. Interfaces only enforce what must be implemented. Abstract classes can have implementation.
A Pure Abstract class is the closest you can get to an interface in C++ but a pure abstract can also have data defined for use when inherited. A Pure Abstract class in C# for example doesn’t mean you can also inherit from another class - you cannot. So, with a single inheritance model like this, having an interface type for enforcing implementation requirements is important. They behave more like a contract really, enforcing the defined requirements at compile time.
So, Interfaces are not the same as Pure Abstracts from that point of view.
Back to multiple inheritance - C++ supports inheritance from multiple classes and they do not have to be pure abstracts or abstracts even. In fact, often this has a major advantage as you can have an abstract with some common functionality but no need for a pure abstract class above it like you would often do with C# Interfaces.
You might argue it is semantics, but it is an incredibly important distinction to be aware of.
In addition to this, C++ has one other major key difference over languages like C# or Java and that it is a multi-paradigm language. It is possible and in fact completely valid to create an application without any classes or use of classes at all - procedural implementation.
So, it is important to be aware of this. I hope this clarifies why interfaces and abstracts are not the same thing, and why C++ doesn’t actually have interfaces (in that they aren’t required due to multiple inheritence)