C++20 - The Complete Guide

C++20 - The Complete Guide by Nicolai M. Josuttis Giving guidance on how to use the new language and library features of C++20 For programmers, who already know C++ and want to switch to the brand new features of C++20 Buy early, pay less, free updates This book is written and will be published incrementally (step-by-step) at leanpub, so that you can benefit from it without waiting until all is done. The first public version was available in June 2021. You can buy the ebook for a reduced price and get all ebook updates for free. First draft is out and available here

C++20 is the latest evolution in modern C++ programming, which will soon become supported by the latest version of gcc, clang, and Visual C++. It is a big step, maybe even bigger than C++11 was. It contains a couple of new key features (modules, concepts, ranges, corountines) plus several small but valuable language and library features, which again will change the way we program in C++. This applies to both application programers and programmers providing foundation libraries. This book will present all the new language and library features of C++20. It will cover the motivation and context of each new feature with examples and background information. As usual for books by Nicolai Josuttis, the focus lies on the application of the new features in practice and will demonstrate how features impact day-to-day programming and how to benefit from them in projects. Nicolai M. Josuttis is well known in the programming community for his authoritative books and talks. For more than 20 years he is a member of the C++ Standard Committee. He is the (co-)author of several worldwide best-sellers, including C++17 - The Complete Guide, all new language and library features of C++17 C++ Move Semantics - The Complete Guide, all aspects of move semantics in one book The C++ Standard Library, the book about the C++ Standard Library, first publication in 1999 C++ Templates - The Complete Guide (with David Vandevoorde and Doug Gregor), the book about templates

Table of Content:
(Green marked topics are already covered)

• Concepts:
  • Motivation, benefits, limitations, drawbacks
  • How to define a concept
  • Concepts as type constraints for auto parameters
  • Concepts and sub-concepts
  • Subsumption
  • Concepts versus type traits and variable templates
  • requires clauses and trailing requires clauses
  • requires expressions
  • Concepts with non-type template parameters
  • Why same_as<> is commutative
  • Documenting all standard concepts
    • Arithmetic concepts, object concepts, concepts for releations between types, comparison concepts
    • Concepts for ranges and view, concepts for pointer-like types, iterator concepts, algorithm concepts
    • Concept for callables, concepts for callables and iterators
    • Auxiliary concepts
  • Documenting all supporting type functions
  • ...

• Ranges and Views:
  • Ranges and Views
    • Motivation of ranges
    • Views
    • Projections
    • Range adaptors and pipelines
      • Lazy evalutation
      • Performance issues
      • Write access
      • Dealing with prvalues
    • Sentinels
    • Implementing ranges and views
    • Borrowed iterators and ranges
    • Limitations and drawbacks of ranges and views
    • const issues with ranges and views
      • Removed propagation of constness
      • cbegin() and cend() are broken for views
      • Why universal/forwarding references have to be used
  • Ranges in detail
    • Documenting all range algorithms
    • Documenting all standard range concepts
    • Documenting all supporting type functions for range
    • New iterator types
      • counted_iterator
      • common_iterator
      • default_sentinel
      • unreachable_sentinel
  • First-class range adapters in detail
    • counted()
    • all() and all_t
    • common()
  • Views in detail
    • view_interface
    • subrange, ref_view, common_view
    • take_view, take_while_view, drop_view, drop_while_view, filter_view
    • transform_view, elements_view, keys_view, values_view
    • split_view, lazy_split_view, join_view
    • reverse_view
    • iota_view, single_view, empty_view, basic_istream_view, basic_string_view
    • some details are missing
  • std::span<>
    • Span versus Subranges
    • Dynamic versus fixed extent
    • Const correctness with std::span<>
    • All operators
  • Range utilities
    • Why std::ranges utilities over std utilities
    • Type functions: std::ranges::iterator_t, std::ranges::range_value_t, ...
    • Range functions: std::ranges::begin(), std::ranges::end(), std::ranges::size(), ...
    • Iterator functions: std::ranges::distance(), std::ranges::next(), std::ranges::prev(), std::ranges::advance()

• Spaceship operator
  • operator<=>
  • Strong/total ordering, weak ordering, and partial ordering
  • Rewritten operator calls

• Compile-Time and Template Improvements:
  • Ordinary functions with auto
  • Template syntac for generic lambdas
  • New types for non-type template parameters(NTTP's)
    • Floating-point values as NTTP's
    • Objects as NTTP's
    • String literals as NTTP's
    • Lambdas as NTTP's
    • Details
• consteval, constinit
• is_constant_evaluated()
• Lambdas and consteval
• Compile-time computing with new/allocators, try/catch, vectors, strings
• Aggregate initialization with parentheses
• Skipping typename
• New type traits:
  • is_bounded_array, is_unbounded_array, is_nothrow_convertible,
  • remove_cvref, unwrap_reference, unwrap_ref_decay, common_reference
  • type_identity
  • is_layout_compatible, is_layout_pointer_interconvertible
• is_pointer_interconvertible_with_class(), is_corresponding_member()
• ...

• Modules:
  • Motivation and use cases
  • module, export, and import
  • Primary module interface units
  • Module implementation units
  • Internal partitions (partition implementation units)
  • Interface partitions (partition interface units)
  • Global module fragments
  • Private module fragments
  • Dealing with header files
  • Dealing with standard header files
  • Converting from header files to module interface units
  • Using modules in practice
    • file extensions
    • compiler options
  • ...

• Other core features
  • Variadic captures
  • Using declarations for enums
  • Conditional explicit
  • Type char8_t
  • New attributes
    • likely / unlikely
    • no_unique_address

• Coroutines
• Introduction and a first complete example with promise_type and coroutine interface
• Promise types
• Coroutine interfaces and coroutine handles
• Using co_await
• Using co_yield
• Using a coroutine as a range
• Using co_return
• A coroutine using multiple threads
• Coroutines in detail
• When coroutines do not return a coroutine interface

• Multi-Threading and Concurrency Features:
  • std::jthread and stop tokens
  • Latches
  • Barriers
  • Semaphores (counted and binary)
  • Atomic references with atomic_ref<>
  • Atomic shared pointers
  • Atomic floating-point types
  • Atomic wait() and notifications
  • atomic_flag extensions

• Formatting
  • Using format(), format_to_n(), and format_to()
  • Standard formatters
  • User-defined formatters

• Calendar dates and time zones for <chrono>
  • Motivation (history and examples)
  • New duration, date, time, and time zone types
  • New clocks and timepoint types
  • Default output, formatted output, and formatted parsing
  • Dealing with invalid dates and times
  • How to deal with leap seconds
  • How to deal with time zones and their abbreviations
  • Why a year may have 365 days, 366 days, or 365.2425 days (plus 1 or 2 seconds)
  • Clock conversions
  • Using clocks with the filesystem library

• Other Library Features
  • Sync Streams
  • New string members
  • reserve() for strings
  • std::source_location
  • unseq execution policy
  • ssize()

• Feature Test Macros

• Deprecated/Removed Features:
  • Deprecated is_pod<>

A draft version of the book is available for a reduced price here (you get all updates for free).

Note that you can also book inhouse trainings about Modern C++ and C++20 (both the language and its standard library) .