C++ has probably the longest learning curve of any mainstream language. Its learning curve is difficult for both technical and (for lack of a better word) political reasons.
On the technical side, C++ supports programming at both high and low abstraction levels. Safety and convenience features (e.g. automatic memory management via smart pointers) require explicit opt-in. The most obvious way to do something is rarely the best way. (For example, string literals are C-style
char*, but the idiomatic C++ way of handling strings is to use
std::string.) Because of C++'s low-level features, most high-level abstractions can be broken by a sufficiently naive or determined programmer. In languages like Java, the high-level abstractions are much less leaky.
On the political side, C++ is focused heavily on backwards compatibility and a lot of cruft has accumulated. Things like its module system (or lack thereof), its use of textual macros and certain syntax elements might be drastically improved/simplified and convenience and safety features more easily added if this constraint were relaxed. It's also designed around ANSI and ISO standards, and several competing implementations exist. None of these implement the standard perfectly, none is considered a de facto or de jure reference implementation, and the standard leaves a lot of behavior undefined or implementation defined. Therefore, code that works today on your compiler will frequently break when ported to a different compiler or compiler version. To write portable C++ code, you need to become somewhat of a language lawyer.