I was one of those who was vehemently anti-C++. Then I read the source code for LLVM (or, large chunks of it...it's a rather large code base). Now I am of the opinion that beautiful things can be created in C++ as well, it just takes considerably more talent than were you to use any other language.
Actually, C++ is bad by definition. The C++ standard has some serious deficiencies that make it harder to write reliable code (and forget maintenance). Part of the problem is that the C++ standard is written with compiler writers in mind, rather than with C++ users in mind, and so some things (like not unwinding the stack until an exception is caught, thus avoiding the double exception fault) are not done, and new problems are simply layered on (like causing the default behavior for exceptions propagating out of destructors to be program termination).
At this point, C++ should be placed in the same category as COBOL: it is a language you learn because you need to maintain some old code that nobody has time to rewrite or replace.
"the C++ standard is written with compiler writers in mind, rather than with C++ users in mind" Just looking at the enormous lengths compilers have to go through to correctly parse C++ should tell you this isn't true. C++ does have some rather glaring deficiencies, but the idea that they're there to make compiler writers lives easier is outrageous to say the least.
Sure, it is hard to write a C++ compiler. Yet neither the C++98 standard nor TR1 fixed the template/right problem, despite it being a major source of headaches among C++ programmers, because compiler writers complained about the complexity it would have added to the grammar. It was not until the majority of commonly-used C++ compilers began to emit a suggestion about the problem that the committee finally fixed it in C++11, and even then, the committee had to convince compiler writers that it was a good idea. That same pattern of behavior can be seen with the double exception faults: compiler writers were unwilling to put in the effort needed to catch an exception before the stack is unwound (without making compiled code slower), and so instead the standard was updated to further cement the idea that destructors should never throw exceptions.
No, it is not purely for compiler writers, but compiler writers and library implementors are a powerful group on the standards committee.
What you're describing sounds more like "C++ strikes a balance between features and implementation difficulty" not "C++ is written for compiler writers." And even that's charitable because it's not like we haven't gotten hard to implement features either. Templates (especially SFINAE), lambdas, and even concurrency and generalized attributes are all places where implementation difficulty was trumped by users. I do agree that compiler/library writers can slow down good features, but they have an important position that needs to be heard and weighed with every other voice too.
