Blog

I'm happy to announce that I'm writing a book about C++20: Programming with C++20 - Concepts, Coroutines, Ranges, and more.

I started writing this book back in May 2020 together with a publisher. Over the last months, it turned out that things aren't as both sides expected them to be, and we decided to go separate ways.

The good thing about this is that I can write the book like I want it to be. As a plus, you all can assist in making Programming with C++20 a great book with your feedback.

I'm delighted that Frances Buontempo, who was there from the beginning, agreed to continue working as a technical reviewer. Her feedback was vital to improve various parts of the book and, of course, my English grammar :-) I also hope to get another expert in.

I will use the same approach as I already did with Notebook C++ - Tips and Tricks with Templates. I started publishing the book at Leanpub this week. That way, I can finish the book and incorporate your feedback.

After the book is finished, I will most likely use Amazon's KDP for producing a paperback version.

Now, about the book. The goal of the book is to teach C++ programmers the new elements of C++20. For that, I assume that readers are familiar with at least C++11. Whenever I use an element from C++14 or C++17, an additional box briefly introduces this element. Such a box aims to bring you up to speed, not to explain a pre-C++20 element in-depth. Below you find a preliminary table of contents. Things are still subject to change, but there are already six complete chapters and two in a review stage.

As you can see from the ToC some features are missing. I intend to keep this book within less than 400 pages. I also use examples and comparisons to former standards showing you the improvements and giving you some ideas about applying the new features in your codebase. All examples will be available on GitHub soon.

For a brief peek, here is a preliminary table of contents:

• 1 Concepts: Predicates for strongly typed generic code
  • 1.1 Programming before Concepts
    • 1.1.1 The enable_if requirement
    • 1.1.2 Long error messages from template errors
  • 1.2 What are Concepts
    • 1.2.1 Thinking in concepts
    • 1.2.2 Concepts and types
  • 1.3 The anatomy of a concept
  • 1.4 Existing Concepts
  • 1.5 The requires-clause: The runway for Concepts
  • 1.6 The requires-expression
    • 1.6.1 Simple requirement
    • 1.6.2 Nested requirement
    • 1.6.3 Compound requirement
    • 1.6.4 Type requirement
    • 1.6.5 Complete constrained version of add
  • 1.7 Adding Concepts to make requirements reusable
  • 1.8 Testing requirements
  • 1.9 Using a Concept
    • 1.9.1 Using a constexpr function in a concept
    • 1.9.2 Applying a concept with a requires-clause
    • 1.9.3 Applying a concept with a trailing requires-clause
    • 1.9.4 Applying a concept as a type-constraint
  • 1.10 Abbreviated function template with auto as generic parameter
    • 1.10.1 What does such a construct do?
    • 1.10.2 Exemplary use case: Requiring a parameter type to be an invocable
  • 1.11 Concepts and constrained auto types
    • 1.11.1 Constrained auto variables
    • 1.11.2 Constrained auto return-type
  • 1.12 The power of Concepts: requires instead of enable_if
    • 1.12.1 Call method based in requires
    • 1.12.2 Conditional copy operations
    • 1.12.3 Conditional destructor
    • 1.12.4 Conditional methods
  • 1.13 Concepts ordering
    • 1.13.1 Subsumption rules details
    • 1.13.2 One more thing, never say not
  • 1.14 Improved error message
• 2 Coroutines
  • 2.1 Regular functions and their control flow
  • 2.2 What are Coroutines
    • 2.2.1 Generating a sequence with coroutines
  • 2.3 The elements of Coroutines in C++
    • 2.3.1 Stackless Coroutines in C++
    • 2.3.2 The new kids on the block: co_await, co_return and co_yield
    • 2.3.3 The generator
    • 2.3.4 The promise_type
    • 2.3.5 An iterator for generator
    • 2.3.6 Coroutine customization points
    • 2.3.7 Coroutines restrictions
  • 2.4 Writing a byte stream parser the old way
  • 2.5 A byte stream parser with Coroutines
    • 2.5.1 Writing the Parse function as coroutine
    • 2.5.2 Creating an Awaitable type
    • 2.5.3 A more flexible promise_type
    • 2.5.4 Another generator the FSM
    • 2.5.5 Simulating a network byte stream
    • 2.5.6 Plugging the pieces together
  • 2.6 A different strategy of the Parse generator
  • 2.7 Using a coroutine with custom new / delete
  • 2.8 Using a coroutine with a custom allocator
  • 2.9 Exceptions in coroutines
• 4 std::ranges
• 5 Modules
• 5 std::format: Modern & type-safe text formatting
  • 5.1 Formatting a string before C++20
    • 5.1.1 Formatting a stock index with iostreams
    • 5.1.2 Formatting a stock index with printf
  • 5.2 Formatting a string using std::format
    • 5.2.1 std::format specifiers
    • 5.2.2 Escaping
    • 5.2.3 Localization
    • 5.2.4 Formatting floating-point numbers
  • 5.3 Formatting a custom type
    • 5.3.1 Writing a custom formatter
    • 5.3.2 Parsing a custom format specifier
  • 5.4 Referring to a format argument
  • 5.5 Using a custom buffer
    • 5.5.1 Formatting into a dynamically sized buffer
    • 5.5.2 Formatting into a fixed sized buffer
  • 5.6 Writing our own logging function
    • 5.6.1 Prefer make_format_args when forwarding an argument pack
    • 5.6.2 Create the format specifier at compile-time
    • 5.6.3 Formatting the time
• 6 Three-way comparisons: Simplify your comparisons
  • 6.1 Writing a class with equal comparison
    • 6.1.1 Comparing different types
    • 6.1.2 Less hand-written code with operator reverse, rewrite and =default
  • 6.2 Writing a class with ordering comparison pre C++20
  • 6.3 Writing a class with ordering comparison in C++20
    • 6.3.1 Member-wise comparison with =default
  • 6.4 The different comparison categories
    • 6.4.1 The comparison categories
    • 6.4.2 The comparison strength: strong or weak
    • 6.4.3 Another comparison strength: partial ordering
    • 6.4.4 Named comparison functions
  • 6.5 Converting between comparison categories
  • 6.6 New operator abilities: reverse and rewrite
  • 6.7 The power of the default spaceship
  • 6.8 Applying a custom sort order
  • 6.9 Spaceship-operator interaction with existing code
• 7 Lambdas in C++20: New features
  • 7.1 [=, this] as a lambda capture
  • 7.2 Default constructible lambdas
  • 7.3 Captureless lambdas in unevaluated contexts
  • 7.4 Lambdas in generic code
    • 7.4.1 Lambdas with templated-head
    • 7.4.2 Variadic lambda arguments
    • 7.4.3 Forwarding variadic lambda arguments
  • 7.5 Pack expansions in lambda init-captures
  • 7.6 Restricting lambdas with Concepts
• 8 Aggregate initialization
  • 8.1 What is an aggregate
  • 8.2 Designated initializers
    • 8.2.1 Designated initializers in C
    • 8.2.2 Designated initializers in C++20
    • 8.2.3 Initializing a subset of an aggregate with designated initializers
    • 8.2.4 Initialize a subset with designated initializers without in-class member initializers
    • 8.2.5 Named arguments in C++: Aggregates with designated initializers
    • 8.2.6 Overload resolution and designated initializers
  • 8.3 Direct-initialization for aggregates
    • 8.3.1 Initialization forms: Braced or parenthesis initialization
    • 8.3.2 Aggregates with user-declared constructors
  • 8.4 Class Template Argument Deduction for aggregates
• 9 Class-types as non-type template parameters
  • 9.1 What are non-type template parameters again
  • 9.2 The requirements for class types as non-type template parameters
  • 9.3 Class types as non-type template parameters
    • 9.3.1 A first contact with class types as NTTP
    • 9.3.2 What compile-time data do we have
  • 9.4 Building a format function with specifier count check
    • 9.4.1 A first print function
    • 9.4.2 Optimizing the format string creation
    • 9.4.3 Checking the number of specifiers in a format string
    • 9.4.4 Checking if type and specifiers do match
    • 9.4.5 Enable more use-cases and prevent mistakes
• 10 New STL elements
  • 10.1 bit_cast: Reinterpreting your objects
  • 10.2 endian: Endianess detection at compile time
  • 10.3 to_array
  • 10.4 span: A view of continuous memory
  • 10.5 source_location: The modern way of __FUNCTION__
    • 10.5.1 Writing a custom assert function
    • 10.5.2 Writing a custom assert function with C++20
    • 10.5.3 Writing a custom log function with C++20
  • 10.6 contains for all associative containers
  • 10.7 start_with ends_with for std::string
• 11 Language Updates
• 12 Doing (more) things at compile-time
• Acronyms
• Bibliography
• Index

Andreas