- 1. Preface
  - 1.1 Versions of This Book
  - 1.2 Acknowledgments
- 2. About This Book
  - 2.1 What You Should Know Before Reading This Book
  - 2.2 Overall Structure of the Book
  - 2.3 How to Read This Book
  - 2.4 The C++17 Standard
  - 2.5 Example Code and Additional Information
  - 2.6 Feedback
I Basic Language Features
- 3. Structured Bindings
  - 3.1 Structured Bindings in Detail
  - 3.2 Where Structured Bindings can be Used
    - 3.2.1 Structures and Classes
    - 3.2.2 Raw Arrays
    - 3.2.3 std::pair, std::tuple, and std::array
  - 3.3 Providing a Tuple-Like API for Structured Bindings
  - 3.4 Afternotes
- 4. if and switch with Initialization
  - 4.1 if with Initialization
  - 4.2 switch with Initialization
  - 4.3 Afternotes
- 5. Inline Variables
  - 5.1 Motivation of Inline Variables
  - 5.2 Using Inline Variables
  - 5.3 constexpr now implies inline
  - 5.4 Inline Variables and thread_local
  - 5.5 Afternotes
- 6. Aggregate Extensions
  - 6.1 Motivation for Extended Aggregate Initialization
  - 6.2 Using Extended Aggregate Initialization
  - 6.3 Definition of Aggregates
  - 6.4 Backward Incompatibilities
  - 6.5 Afternotes
- 7. Mandatory Copy Elision or Passing Unmaterialized Objects
  - 7.1 Motivation for Mandatory Copy Elision for Temporaries
  - 7.2 Benefit of Mandatory Copy Elision for Temporaries
  - 7.3 Clarified Value Categories
    - 7.3.1 Value Categories
    - 7.3.2 Value Categories Since C++17
  - 7.4 Unmaterialized Return Value Passing
  - 7.5 Afternotes
- 8. Lambda Extensions
  - 8.1 constexpr Lambdas
  - 8.2 Passing Copies of this to Lambdas
  - 8.3 Afternotes
- 9. New Attributes and Attribute Features
  - 9.1 Attribute [[nodiscard]]
  - 9.2 Attribute [[maybe_unused]]
  - 9.3 Attribute [[fallthrough]]
  - 9.4 General Attribute Extensions
  - 9.5 Afternotes
- 10. Other Language Features
  - 10.1 Nested Namespaces
  - 10.2 Defined Expression Evaluation Order
  - 10.3 Relaxed Enum Initialization from Integral Values
  - 10.4 Fixed Direct List Initialization with auto
  - 10.5 Hexadecimal Floating-Point Literals
  - 10.6 UTF-8 Character Literals
  - 10.7 Exception Specifications as Part of the Type
  - 10.8 Single-Argument static_assert
  - 10.9 Preprocessor Condition __has_include
  - 10.10 Afternotes
II Template Features
- 11. Class Template Argument Deduction
  - 11.1 Usage of Class Template Argument Deduction
    - 11.1.1 Copying by Default
    - 11.1.2 Deducing the Type of Lambdas
    - 11.1.3 No Partial Class Template Argument Deduction
    - 11.1.4 Class Template Argument Deduction Instead of Convenience Functions
  - 11.2 Deduction Guides
    - 11.2.1 Using Deduction Guides to Force Decay
    - 11.2.2 Non-Template Deduction Guides
    - 11.2.3 Deduction Guides versus Constructors
    - 11.2.4 Explicit Deduction Guides
    - 11.2.5 Deduction Guides for Aggregates
    - 11.2.6 Standard Deduction Guides
  - 11.3 Afternotes
- 12. Compile-Time if
  - 12.1 Motivation for Compile-Time if
  - 12.2 Using Compile-Time if
    - 12.2.1 Caveats for Compile-Time if
    - 12.2.2 Other Compile-Time if Examples
  - 12.3 Compile-Time if with Initialization
  - 12.4 Using Compile-Time if Outside Templates
  - 12.5 Afternotes
- 13. Fold Expressions
  - 13.1 Motivation for Fold Expressions
  - 13.2 Using Fold Expressions
    - 13.2.1 Dealing with Empty Parameter Packs
    - 13.2.2 Supported Operators
    - 13.2.3 Using Fold Expressions for Types
  - 13.3 Afternotes
- 14. Dealing with Strings as Template Parameters
  - 14.1 Using Strings in Templates
  - 14.2 Afternotes
- 15. Placeholder Types like auto as Template Parameters
  - 15.1 Using auto as Template Parameter
    - 15.1.1 Parameterizing Templates for Characters and Strings
    - 15.1.2 Defining Metaprogramming Constants
  - 15.2 Using auto as Variable Template Parameter
  - 15.3 Using decltype(auto) as Template Parameter
  - 15.4 Afternotes
- 16. Extended Using Declarations
  - 16.1 Using Variadic Using Declarations
  - 16.2 Variadic Using Declarations for Inheriting Constructors
  - 16.3 Afternotes
III New Library Components
- 17. std::optional<>
  - 17.1 Using std::optional<>
    - 17.1.1 Optional Return Values
    - 17.1.2 Optional Arguments and Data Members
  - 17.2 std::optional<> Types and Operations
    - 17.2.1 std::optional<> Types
    - 17.2.2 std::optional<> Operations
  - 17.3 Special Cases
    - 17.3.1 Optional of Boolean or Raw Pointer Values
    - 17.3.2 Optional of Optional
  - 17.4 Afternotes
- 18. std::variant<>
  - 18.1 Using std::variant<>
  - 18.2 std::variant<> Types and Operations
    - 18.2.1 std::variant<> Types
    - 18.2.2 std::variant<> Operations
    - 18.2.3 Visitors
    - 18.2.4 Valueless by Exception
  - 18.3 Special Cases
    - 18.3.1 Having Both bool and std::string Alternatives
  - 18.4 Afternotes
- 19. std::any
  - 19.1 Using std::any
  - 19.2 std::any Types and Operations
    - 19.2.1 Any Types
    - 19.2.2 Any Operations
  - 19.3 Afternotes
- 20. std::byte
  - 20.1 Using std::byte
  - 20.2 std::byte Types and Operations
    - 20.2.1 std::byte Types
    - 20.2.2 std::byte Operations
  - 20.3 Afternotes
- 21. String Views
  - 21.1 Differences to std::string
  - 21.2 Using String Views
  - 21.3 Using String Views Similar to Strings
    - 21.3.1 String View Considered Harmful
  - 21.4 String View Types and Operations
    - 21.4.1 Concrete String View Types
    - 21.4.2 String View Operations
    - 21.4.3 String View Support by Other Types
  - 21.5 Using String Views in API’s
    - 21.5.1 Using String Views to Initialize Strings
    - 21.5.2 Using String Views instead of Strings
  - 21.6 Afternotes
- 22. The Filesystem Library
  - 22.1 Basic Examples
  - 22.2 Principles and Terminology
    - 22.2.1 General Portability Disclaimer
    - 22.2.2 Namespace
    - 22.2.3 Paths
    - 22.2.4 Normalization
    - 22.2.5 Member versus Free-Standing Functions
    - 22.2.6 Error Handling
  - 22.3 Many Details UNDER CONSTRUCTION
  - 22.4 Afternotes
IV Library Extensions and Modifications
- 23. Type Traits Extensions
  - 23.1 Type Traits Suffix _v
  - 23.2 New Type Traits
  - 23.3 std::bool_constant<>
  - 23.4 std::void_t<>
  - 23.5 Afternotes
- 24. Parallel STL Algorithms
  - 24.1 Using Parallel Algorithms
    - 24.1.1 A Standard Algorithms in Parallel
    - 24.1.2 Using New Algorithms
  - 24.2 Parallel Algorithms in Detail
  - 24.3 Afternotes
- 25. Container Extensions
  - 25.1 Container-Support of Incomplete Types
  - 25.2 Node Handles
  - 25.3 Afternotes
- 26. Multi-Threading and Concurrency
  - 26.1 Supplementary Mutexes and Locks
    - 26.1.1 std::scoped_lock
    - 26.1.2 std::shared_mutex
  - 26.2 is_always_lock_free() for Atomics
  - 26.3 Cache-Line Sizes
  - 26.4 Afternotes
V Expert Utilities
- 27. new and delete with Over-Aligned Data
  - 27.1 Using new with Alignments
    - 27.1.1 Distinct Dynamic/Heap Memory Arenas
    - 27.1.2 Passing the Alignment with the new Expression
  - 27.2 Implementing operator new() for Aligned Memory
    - 27.2.1 Implementing Aligned Allocation Before C++17
    - 27.2.2 Implementing Type-Specific operator new()
  - 27.3 Implementing Global operator new()
    - 27.3.1 Backward Incompatibilities
  - 27.4 Tracking all ::new Calls
  - 27.5 Afternotes
- 28. Other Library Improvements for Experts
  - 28.1 Low-Level Conversions between Character Sequences and Numeric Values
    - 28.1.1 Example Usage
  - 28.2 Afternotes
- Glossary
  - F
    - full specialization
  - I
    - incomplete type
  - P
    - partial specialization
  - V
    - variable template
    - variadic template
- Index
Notes

About

Authors

Author Support

More

Legal