Nicolai M. Josuttis

My only substantive disappointment with what is otherwise a very good reference for the changes brought by C++20 is that the book has several sections that contain only the placeholder text "This chapter/section is at work" (meaning, I assume, that it is a work in progress). Most of the sections so marked are probably quite minor, but the absence of section 19.3, "Details of Objects as NTTPs" is particularly frustrating, as that was one of the sections that I expected to be particularly enlightening.

In other words, the book -- or at least my copy -- is incomplete. Nothing warned me before I bought it that that was the case. Indeed, the author's web page stated that the hardcopy book was "100%" complete.

In the text, the English is only rarely ambiguous or confusing, although it is more frequently rendered in a manner that a native speaker of the language (or at least this native speaker of the language) finds stilted and slightly unnatural.

While the book seems solid on the mechanics of the new C++20 features, and contains many pieces of example code illustrating their use, nowhere does it provide something that would be at least as useful: explanations of why they were added to the language, and when to use them.

C++20 is somewhat of a monster, and I have yet to see clear explanations of why, for example, one might choose to use ranges or coroutines to solve a problem over other, more conventional, methods. For the most part, the new features don't seem to involve writing *less* code, just *different* code. And while I can imagine that, for example, range-based code might result in more efficient executable code at the CPU level, I have seen, neither in this book nor elsewhere, any objective measurements to suggest that reformulating the manner in which loops over containers are written so as to use ranges actually results in programs that are more efficient.

Similarly, coroutines are a complex new feature that we have managed without until now; so why are they suddenly a good thing? All the examples of their use that I have seen are basically an inordinately complicated way to solve a not-very-practical problem that I have never seen occur in real life.

So, while this book is very good as a reference for the new features, there is definitely room for a more descriptive book to explain why and when to use the features that this book (mostly) describes so well.… (mere)

A useful book, collecting much of the wisdom about the subject in one place.

However, it could have been so much better if:

1) It had been proofread properly;

2) The examples (most of which use strings) had eschewed C-style strings (does anyone actually use those in new code any more?) and instead used proper C++-style std::strings throughout (with C++ literal initialisation) and also some examples with std::string_view. This lack I find incomprehensible in a book focussed on what is generally called "Modern C++", and considerably impacts the utility of the book.

Further, the presence of a political agenda was an obvious mistake that I hope the author will be at pains never to repeat in his generally-useful technical books. I suspect that for many readers it will have an effect precisely opposite to that intended.… (mere)