Despite working in C++ a lot, I despise it as a language. C is full of undefined (or ill-defined) behavior, which C++ doggedly sticks to under the misbegotten ideal of backwards compatibility. C++ then adds heaping mounds of its own complexity, extending and amplifying these undefined behaviors.
C has automatic type coercion, but only for basic types and with well defined (but NOT portable) rules; C++ adds user-defined automatic type coercion, so something as simple as passing an integer literal into a function could trigger a non-trivial amount of program logic. Moreover, automatic type coercion makes it impossible to specialize a function based on return type. Automatic type coercion made it necessary to add explicit to the language.
C++ completely screwed up const. It was supposed to be concrete and shallow, like literally, you can't change the bits of this thing (at least in this scope). C++ made const abstract and deep, which then made it necessary to introduce mutable, which completely breaks const. In C, const meant you can't write to it, so unless it was volatile, the compiler could optimize on the const-ness. A C++ compiler can't make that assumption, because of mutable.
C++ screwed up object instantiation. RAII is not how computers actually work. Allocation and initialization are not atomic operation. Allocation can fail, requiring an out-of-bounds signal (an exception) to indication that something went wrong; whereas C could return NULL. Initialization could fail (e.g. bad arguments) again requiring an out-of-bounds signal. Other languages can accomplish the same thing with normal program logic. For example, Swift's exceptions are not out-of-bounds, they're syntactic sugar for functions that return false or null when an "exception" is thrown. If you use RAII (the default policy) in C++, then you must pay the price for heavy-weight exception handling or suffer undefined behavior. And you can't get value-type semantics without RAII.
C++ even screwed up its object model. C++ uses isa with multiple inheritance of implementation and dynamic (vtable) dispatch. Java got this right, Swift got this right, isa (i.e. inheritance of implementation) should only ever be single inheritance, whereas acts-like-a (i.e. inheritance of interface) can be multiple inheritance. Even Python and Perl got this right.
In short, C++ requires the programmer to use extreme self-discipline or pay a huge penalty in complexity and undefined behavior. C has undefined behavior but without the complexity. Swift has the complexity but without the undefined behavior. C++ is the worst of both worlds.
