The standard libraries offer very poor functionalities compared to other languages' runtimes and frameworks.
C++ doesn't enforce a single paradigm. Neither procedural nor object-oriented paradigms are enforced, resulting in unnecessary complication.
The specification has grown to over 600 pages, which reflects the bulky nature of C++.
Not suitable for low level system development and quickly becomes a mess for user level applications.
The standard has no implementation for exception handling and name mangling. This makes cross-compiler object code incompatible.
The nature of C++ has led developers to write compiler dependent code, creating incompatiblity between different compilers and even different versions of the same compiler.
No widely used OS supports the C++ ABI for syscalls.
C++ supports 'goto'.
What is 's', a function or a variable?
std::string s();
There is try but no finally
No native Unicode support. You just can't write international and portable programs.
No native thread support!! You can't even write portable multithreaded programs!!
There's a moment in every C++ programmer's life where he wonders why, why, switch case fall-through has been invented: it's completely useless, and if you forget a break you introduce a bug silently.
Not to mention a classic:
if (a = b) // forgot an =; condition is true if b != 0
{
...
An std::string::c_str() call is required to convert an std::string to a char*. From the most powerful language ever we would have all appreciated a goddamn overloaded operator char* ().
Operators can be overloaded only if there's at least one class parameter.
This also makes impossible concatenating character array strings, sometimes leading programmers to use horrible C functions such as strcat.
catch (...) doesn't allow to know the type of exception.
throw in function signatures is perfectly useless.
The exception system is not integrated with the platform: dereferencing a NULL pointer will not throw a C++ exception.
Developers have to worry about optimization matters such as whether declaring a function inline or not; and, once they've decided to do it, it is only a suggestion: the compiler may decide that was an incorrect suggestion and not follow it. What's the point? Shouldn't developers worry about optimization matters?
To rectify this nonsense many compilers implement __forceinline or similar.