![Cover of Modern C[plus plus] design](/covers/OL8021675W-480.webp)
[1] Addmittedly, Andrei's notion is still completely relevant today (and still, imo, the best C++ book available) but I don't think it's what most people think of when they hear the term "modern c++" these days. - https://en.wikipedia.org/wiki/Modern_C%2B%2B_Design
[2] https://github.com/isocpp/CppCoreGuidelines/blob/master/CppC...
Probably does something cool for all that crazy though?
Let alone those that aren't neither WG21 members, nor C++ compiler vendors.
Let me say that I think the same about this comment of yours upthread:
>>D would deserve attention too, in a separate post, or here if it was explained how it relates to Aro.
In case you cannot or don't want to google for some reason, here are the Wikipedia articles about D, Walter and Andrei, and important related topics (all on Wikipedia, which implies notability) that I suggested you look up, above:
https://en.m.wikipedia.org/wiki/Walter_Bright
https://en.m.wikipedia.org/wiki/Zortech_C%2B%2B
https://en.m.wikipedia.org/wiki/Empire_(1977_video_game)
https://en.m.wikipedia.org/wiki/D_(programming_language)
https://en.m.wikipedia.org/wiki/Andrei_Alexandrescu
https://en.m.wikipedia.org/wiki/Modern_C%2B%2B_Design
https://en.m.wikipedia.org/wiki/C%2B%2B
Edit: spelling
* They added smart pointers that actually work. (std::unique_ptr and std::smart_ptr) Invoking delete is considered a code smell in C++11, and new is considered a code smell in C++14. (because of make_unique and make_shared, added in C++14)
* Dynamic polymorphism (via inheritance) has gone out of style. These days it's templates all the way down, which aren't terrible anymore for a wide variety of reasons that I don't have time to go into.
* Threads and safe locking mechanisms are now actually standardized, so you don't have to use boost::thread. std::async, lambdas, and std::future provide reasonable syntactic sugar around threading, as opposed to manually mucking around with your own thread pool.
* Stuff that used to require library writers to dig around in the bowels of template metaprogramming became a lot easier with `if constexpr` in C++17. Actually that's one of the reasons why templates aren't terrible anymore, sorry for going into it when I said I wouldn't.
Idiomatic C++17 code feels like a completely different language than C++03. Ye olden C++ felt like Java with spike traps and no garbage collector, but idiomatic C++17 feels like... I dunno, Rust without the borrow checker and everything is in an unsafe block. (I'm trying to think of a better example)
(as an aside, there are two different things called "modern c++". I'm pretty sure it's a joke, but it's a terrible one. There's Andrei Alexandrescu's 2001 book Modern C++, and there is are the coding practices that evolved out of the development of C++11/14/17.)
Source: I maintain a ye olden C++ codebase at work, and write modern C++17 in my personal projects. The degree to which they differ is profound. I'm not doing the difference justice.