C++20 - The Complete Guide

C++20 - The Complete Guide

Cover C++20
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.

A draft ebook (having already 580 pages) is already 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
  - Overview of all range algorithms
  - Documenting all standard range concepts
  - Documenting all supporting utility functions, types, and type traits for ranges
    - std::ranges::begin(), std::ranges::range_value_t, ...
  - Documenting all new utilities for other types
    - std::ranges::swap(), std::iter_value_t, std::projected, std::identity, ...
  - 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()

Comparisons and Operator <=>:
- Rewritten operator calls
- Operator <=>
- Strong/total ordering, weak ordering, and partial ordering
- Implementing operator<=> (with compare_three_way and compare_three_way_result_t)
- Mapping comparison categories
- Algorithm lexicographical_compare_three_way()
- Traps when using operator <=>

Compile-time and template improvements:
- Ordinary functions with auto
- Lambda templates (template syntac for generic lambdas)
  - versus variable templates
- 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 extensions with constexpr
Using vectors and strings at compile time
Implicit 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
- iter_difference_t, iter_value_t, iter_reference_t, iter_rvalue_reference_t
is_pointer_interconvertible_with_class(), is_corresponding_member()
...

Modules:
- Motivation and use cases
- module, export, and import
- Reachable versus visisble
- 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
- Umbrella modules
- Using modules in practice
  - file extensions
  - compiler options
  - fixing Visual C++

Other core features
- Lambda extensions
  - Explicit template parameters for generic lambdas
  - Default constructor for lambdas without captures
  - Lambdas as non-type template parameters
  - consteval lambdas
  - New rules for capturing members, this, and *this
  - Capturing structure bindings
  - Init-capturing parameter packs
  - Coroutine lambdas
- Using declarations for enum values
- Conditional explicit
- Type char8_t
- Range-based for loop with initializer
- New attributes
  - likely and unlikely
  - no_unique_address
  - Argument for nodiscard
- Aggregate extensions and fixes
  - Designated initializers (initial values for specific members)
  - Class template argument deduction (CTAD) for aggregates
  - Aggreates as non-type template parameters
  - Initialization with parentheses
  - Modified definition of aggregates
    - Effect on is_default_constructible<>

Coroutines

Introduction and a first complete example

Coroutine interfaces and coroutine handles
Coroutine promise types

Using co_await
Using co_yield
- Using a coroutine as a generator/range
Using co_return
Coroutine lambdas
Awaitables and Awaiters
- Returning values to co_yield and co_wait
- Symmetric transfer
Coroutines using multiple threads
Coroutines in detail
- Copying and moving coroutines (handles and interfaces)
- API of coroutine handles
- Full API of coroutine promises
- API of awaiters
- Memory management of coroutines (and how to change it)
- await_transform()
- operator co_wait()
coroutine_traits<> (coroutines without a coroutine interface)

Multi-Threading and Concurrency Features:
- std::jthread and stop tokens
  - stop tokens for condition variables
- 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
- osyncstream

Formatting
- Using format(), format_to_n(), and format_to()
- Error handling and std::vformat()
- Standard formatters and standard specifiers
- 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
- String extensions
  - Members starts_with() and ends_with()
  - reserve() no longer may shrink
  - Operator <=> for strings
  - New type std::u8string for UTF-8 character sequences
  - Using compile-time strings
- Extensions for dealing with bits
  - Bit operations
  - std::bit_cast<>()
  - std::endian
  - Header <bit>
- std::source_location
- unseq execution policy
- New algorithms
  - min(), max(), and minmax() for ranges
  - shift_left and shift_right()
  - lexicographical_compare_three_way()
- Safe comparisons of integral values (std::cmp_less() etc.)
- std::ssize() and std::ranges::ssize()

Other features
- Feature test macros
- Header <version>

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) .

C++20 - The Complete Guide

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

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