After writing this, I realized that it became more of a rant about common complaints about C++ than an on-topic reply to the OP's questions. Sorry for derailing the thread.
One tends to see a lot of critisism of C++'s more powerful features. Here's my take on a few of them, and a few of the questions in the original post.
Operator overloading:
Of course it can be abused, just like any other feature in a language. That doesn't mean that it isn't useful. On the contrary, operator overloading (properly used) makes code much more readable. Do you really prefer java's string.equals to an overloaded == operator? If you write a class where size is clearly defined, do you really think instance1.IsGreaterThan(instance2) is more readable than instance1 > instance2? Would you prefer the same treatment of primitive datatypes?
Function overloading:
What's polymorphism without it? The ability to write one base class which implements the basic features of a set of classes saves tons of time, not to mention code repetition (and thus maintainability). Function overloading is great if you want one type of object to behave slightly differently to the others, or return custom data. As an example, I write an app which, among other things, have a few different types of objects like text boxes, pictures, charts, etc which can be dragged around the window to change places, etc. Each of these objects inherits the same base class, which contains functions like GetMinimumSize. Now, because of function overloading, I can have an array containing all the objects, independent of their types, and recalculate the layout without caring about their type. A text box will have a different implementation of GetMinimumSize than a picture, but it all looks the same to the layout calculator. Trying to do this without inheritance would be a real pain.
Classes:
Really, who writes C++ code longer than a few dozen lines without classes?
STL:
I don't use it much myself, mostly because I already have other libs which contains standard functions so one more is just redundant. Not using premade libs greatly increases your workload, because you have to reinvent every wheel yourself (and likely, quite a few of them will be square). Most likely the three dozen or so standard libraries which contain implementations of complex numbers are all better than what one person could produce in a reasonable time anyway.
Single Inheritance:
Again, if you have two very similar classes, why implement all their common functionallity twice?
Templates:
A great tool when you use it right, even if it has a few quirks (especially with visual studio). Not one I use often, but when I need it it's there.
STL strings:
Actually, one of the worst things about C++ (and many other languages) is the string handling. If you use some MFC, some ATL, som STL, etc. you're going to wind up with three dozen different kinds of strings, most of which you'll have to write your custom casting functions between. A quick look in our code reveals ATL::CString, char*, wchar*, wchar_t*, LPOLESTR, LPCTSTR, LPWSTR, TCHAR, PCXSTR, and there's a lot more, not to mention most of these can hold unicode, ascii, etc. And just for kicks, some of these change when you upgrade your compiler and libraries. What I wouldn't give for a single, universal string class, no matter how bad it was.
Multiple Inheritance:
This is also a usefull tool, but careful, careful, it can be a bit tricky at times. On a side note, one of the worst flaws with MFC is that you can't do multiple inheritance if more than one base class inherits from CWnd. And disambiguating CObject members can be a real pain too. Maybe I'm just incompetent, but it seems to me that the language tools for MI is somewhat lacking.
Pointers:
Somehow, on any programming forum, there's allways someone moaning about how difficult pointers are. Huh? Not only can't I really undestand what the problem is (once you've grasped the basic concept that the pointer contains a memory address, what's the difficulty?), I also can't see how doing away with them won't complicate some types of code greatly.
In closing, I'd like to make three points:
Any tool can be abused. Removing or restricting a language feature just because some programmers can't use it properly just punishes those who can. Also, the fact that a tool can be abused doesn't mean that it doesn't have good uses, or that it's use should be considered bad practice.
Noone is forcing you to use any language feature. If you don't like it, don't use it, it's as simple as that.
Use the right tool for the job. C++ is a great multi-purpouse language, but no language is the be-all and end-all of tools. Sometimes batch scripts fit the job better, sometimes javascript is the tool to use. Because a language isn't optimally suited for each and every concievable application doesn't make it useless.