C++ is such an atrociously over-complicated language that its learning curve may get in the way of learning fundamentals. Learning C++ well is a ten-year project, and even experts are frequently surprised by the language.

Subtle errors can render the entire program "undefined" by the complicated C++ standard. The standard imposes no requirements in such cases. Thus C++ compiler writers are free to ignore the existence of such cases and Bad Things are prone to happen instead. Even experts can't reliably avoid undefined cases in C++, so how can beginners be expected to do so?

Many of the concepts are hard to grasp if you have no prior programming experience.

C++ uses the #include mechanism provided by C. Which unfortunately is a poor way of accessing the API of a library. Some of the reasons why the module system is weak are:

• Compile time scalability: The compiler must preprocess every header included in a file, and every header included in those headers. This process must be repeated for every translation unit in the program. As can be imagined, this doesn't scale very well. For each header added you are increasing the compilation time exponentially.

• Fragile: modules included are treated as textual imports by the compiler. This causes all sorts of problems since they are subject to any macro definitions in the time of the inclusion. If any of these macro definitions collide with a name in the library it can break the library API .

The years of cramped backward compatibility start to show in the syntax, complexity and very top-heavy language structures. Trying to keep up with far more elegant languages like C# doesn't do C++ any good either, because the committee always seems to be able to mess it up. After numerous years, still no modules... you must be kidding!

Beginners need fast feedback

Arrays, strings, pointers, etc. have both C and C++ versions. Sometimes the C++ versions are worse. This is more useless trivia beginners have to sort through.

Undefined behavior in a program can cause unexpected results, making it hard to debug. With UB, program behavior may vary wildly depending on optimization settings. There are many cases that invoke UB, such as signed overflow, invalid dereferences, large integer shifts, uninitialized variables, etc. C++ allows for non-type safe operations such as logic errors, wild pointers, buffer overflow, etc. UB and type safety issues create a large number of bugs and security vulnerabilities.

C++ is such a huge and complicated language, that programmers have to learn a disciplined subset of it to reliably get anything done. The problem is, no-one can agree on which subset to use and they can't understand each other.

C++ objects are frustratingly opaque. This makes debugging especially difficult, something beginners have to do a lot.

Because C and C++ allow the user direct access to memory and don't provide garbage collection threads, there is a probability that a program may have a "memory leak", which occurs when something a programmer allocated in the heap is not deallocated properly. Also, attempting to dereference memory protected by the operating system causes a segmentation fault and kills the program.

Although you have several ways to handle strings, all of them are messy and error-prone, giving birth to many crashes and memory corruptions in the field. It's one of the worst languages ever, if you have to do strings.

You can usually get a core dump, but often the call stack gets completely overwritten. Compilers are not even consistent in how they map the binary objects to code.

No modules, just files, and no way to tell where anything came from.