Overloaded  does not.
Yeah it does. a[b] means operator(a,b). It's a function in C++. Some forms are predefined, much like some forms of sqrt, min, and less are predefined, but it's a function nonetheless. C++ is NOT C and if you keep treating it as such, then you'll get confused by such things.
The worse of all is overloaded ->, which is an operator which can normally be applied to a dereferenceable type, so you would really have no idea to even look for an overloaded operator to see if something unexpected is happening,
Except that if you know C++, you know that -> can be overloaded, so you would never expect that user defined types could never be dereferenced. It's not only possibly, it's a really really common idiom. Your reasoning only really works if you assume C++ is really C, and apply all the rules you know from there to C++. It is not. Again, all a->b means is operator->(a, b), which is yet again a function call with a funny syntax.
In my experience, if there are bad paradigms available in the language, people will use them, even celebrating their ability to do something "clever" and obtuse, and
So? It's my experience that people will do stupid things with power tools, up to and including losing digits and limbs. I wouldn't however advocate that we should never use power tools because an awful lot would be vastly slower and more difficult without them. It's the same with powerful language features. You can do stupid stuff with powerful language features. If people are doing stupid stuff with those in your code base, then the problem is not the language, it's your processes. You can, after all, write awful code in any language.
Very often it may not even be in your code base, that you have control of, but in some open source software that you have to read and understand.
When C was popular, there was an awful lot of bad code in C. When C++ became popular, there was an awful lot of bad code in C++. When Java became popular, there was an awful lot of bad code in Java. Nowadays, there's a lot of bad code in all of those plus PHP, Python, Go and a whole host of others.
And on the flip side, there are shining examples of excellence in all of those.
Of course it would be facetious to claim that no language is either better or worse. However, I do dispute that having powerful features inherently makes the language worse. Features that allow you to write the same code more concisely and so with fewer bugs make languages better.
but it's pragmatic to recognize that in a world of imperfect programmers, it's better to not have language features that generally lead to hard to understand code.
Except I dispute that they make it harder to read. Having special syntax makes things easy to read, essentially (I think that's why LISP never took off).  generally means "array access". And in C++ it works for builtin arrays, std::vectors and for various numeric array types, like Eigen. The thing is in all cases it means logically and semantically the same thing, so having it look the same is a huge advantage.
Poorly used, it makes things confusing, just like any other poorly named function. And that's why library writing is generally done by the experienced members of the community or team.