Exploring C++20: The Programmer's Introduction to C++

Table of Contents
About the Author
About the Technical Reviewer
Acknowledgments
Introduction
Part I: The Basics
	Exploration 1: Honing Your Tools
		C++ Versions
		Ray’s Recommendations
			Clang and LLVM
			GNU Compiler Collection
			Microsoft Windows
			Other Tools
		Read the Documentation
		Your First Program
	Exploration 2: Reading C++ Code
		Comments
		Modules
		Main Program
		Variable Definitions
		Statements
		Output
	Exploration 3: Integer Expressions
	Exploration 4: Strings
	Exploration 5: Simple Input
	Exploration 6: Error Messages
		Misspelling
		Bogus Character
		Unknown Operator
		Unknown Name
		Symbol Errors
		Fun with Errors
	Exploration 7: More Loops
		Bounded Loops
			Initialization
			Condition
			Postiteration
			How a for Loop Works
		Your Turn
	Exploration 8: Formatted Output
		The Problem
		Field Width
		Fill Character
		std Prefix
		Alignment
		Exploring Formatting
		Alternative Syntax
		On Your Own
		The format Function
	Exploration 9: Arrays and Vectors
		Vectors for Arrays
		Vectors
		Ranges and Algorithms
	Exploration 10: Algorithms and Ranges
		Algorithms
		Output Iterators
	Exploration 11: Increment and Decrement
		Increment
		Decrement
		Member Types
		Back to Iterators
	Exploration 12: Conditions and Logic
		I/O and bool
		Boolean Type
		Logic Operators
		Old-Fashioned Syntax
		Comparison Operators
	Exploration 13: Compound Statements
		Statements
		Local Definitions and Scope
		Definitions in for Loop Headers
	Exploration 14: Introduction to File I/O
		Reading Files
		Writing Files
	Exploration 15: The Map Data Structure
		Using Maps
		Pairs
		Searching in Maps
	Exploration 16: Type Synonyms
		typedef and using Declarations
		Common typedefs
	Exploration 17: Characters
		Character Type
		Character I/O
		Newlines and Portability
		Character Escapes
	Exploration 18: Character Categories
		Character Sets
		Character Categories
		Locales
	Exploration 19: Case-Folding
		Simple Cases
		Harder Cases
	Exploration 20: Writing Functions
		Functions
		Function Call
		Declarations and Definitions
		Counting Words—Again
		The main() Function
	Exploration 21: Function Arguments
		Argument Passing
		Pass-by-Reference
		const References
		const_iterator
		String Arguments
		Multiple Output Parameters
	Exploration 22: Using Ranges
		Transforming Data
		Predicates
		Other Algorithms
	Exploration 23: Using Iterators
		Transforming Data
		Sorting with Iterators
	Exploration 24: Unnamed Functions
		Lambdas
		Naming an Unnamed Function
		Capturing Local Variables
		const Capture
		Return Type
	Exploration 25: Overloading Function Names
		Overloading
			bool is_alpha(char ch)
			bool is_alpha(std::string_view str)
			char to_lower(char ch)
			std::string to_lower(std::string_view str)
			char to_upper(char ch)
			std::string to_upper(std::string_view str)
	Exploration 26: Big and Little Numbers
		The Long and Short of It
			Long Integers
			Short Integers
		Integer Literals
		Byte-Sized Integers
		Type Casting
		Make Up Your Own Literals
		Integer Arithmetic
		Overload Resolution
	Exploration 27: Very Big and Very Little Numbers
		Floating-Point Numbers
		Floating-Point Literals
		Floating-Point Traits
		Floating-Point I/O
	Exploration 28: Documentation
		Doxygen
		Structured Comments
		Documentation Tags and Markdown
			@b word
			@brief one-sentence-description
			@c word
			@em word
			@file file name
			@link entity text @endlink
			@mainpage title
			@p name
			@par title
			@param name description
			@post postcondition
			@pre precondition
			@return description
			@see xref
			Outline Placeholder
		Using Doxygen
	Exploration 29: Project 1: Body Mass Index
		Hints
Part II: Custom Types
	Exploration 30: Custom Types
		Defining a New Type
		Member Functions
		Constructors
		Overloading Constructors
	Exploration 31: Overloading Operators
		Comparing Rational Numbers
		Arithmetic Operators
		Math Functions
	Exploration 32: Custom I/O Operators
		Input Operator
		Output Operator
		Error State
	Exploration 33: Assignment and Initialization
		Assignment Operator
		Constructors
		Putting It All Together
	Exploration 34: Writing Classes
		Anatomy of a Class
		Member Functions
		Constructor
		Defaulted and Deleted Constructors
	Exploration 35: More About Member Functions
		Revisiting Project 1
		const Member Functions
	Exploration 36: Access Levels
		Public vs. Private
		class vs. struct
		Public or Private?
	Exploration 37: Understanding Object-Oriented Programming
		Books and Magazines
		Classification
		Inheritance
		Liskov’s Substitution Principle
		Type Polymorphism
	Exploration 38: Inheritance
		Deriving a Class
		Member Functions
		Destructors
		Access Level
		Programming Style
	Exploration 39: Virtual Functions
		Type Polymorphism
		Virtual Functions
		References and Slices
		Pure Virtual Functions
		Virtual Destructors
	Exploration 40: Classes and Types
		Classes vs. typedefs
		Value Types
			Copying
			Assigning
			Moving
			Comparing
		Resource Acquisition Is Initialization
	Exploration 41: Declarations and Definitions
		Declaration vs. Definition
		inline Functions
		Variable Declarations and Definitions
		Static Variables
		Static Data Members
		Declarators
	Exploration 42: Modules
		Introducing Modules
		Classes and Modules
		Hiding the Implementation
			Modules Exporting Modules
		Compiling Modules
	Exploration 43: Old-Fashioned “Modules”
		Interfaces As Headers
		Inline or Not Inline
		Quotes and Brackets
		Include Guards
		Forward Declarations
		extern Variables
		One-Definition Rule
	Exploration 44: Function Objects
		The Function Call Operator
		Function Objects
	Exploration 45: Useful Algorithms
		Ranges and Iterators
		Searching
			Linear Search Algorithms
			Binary Search Algorithms
		Comparing
		Rearranging Data
		Copying Data
		Deleting Elements
		Iterators
	Exploration 46: More About Iterators
		Kinds of Iterators
			Input Iterators
			Output Iterators
			Forward Iterators
			Bidirectional Iterators
			Random Access Iterators
			Contiguous Iterators
		Working with Iterators
		const_iterator vs. const iterator
		Error Messages
		Specialized Iterators
	Exploration 47: Ranges, Views, and Adaptors
		Ranges
		Range Views
		Range Pipelines
		Range Adaptors
			The drop View
			The filter View
			The join View
			The keys View
			The reverse View
			The transform View
			The take View
			The values View
	Exploration 48: Exceptions
		Introducing Exceptions
		Catching Exceptions
		Throwing Exceptions
		Program Stack
		Standard Exceptions
		I/O Exceptions
		Custom Exceptions
		When a Function Doesn’t Throw Exceptions
		System Errors
		Exceptional Advice
	Exploration 49: More Operators
		Conditional Operator
		Short-Circuit Operators
		Comma Operator
		Arithmetic Assignment Operators
		Increment and Decrement
	Exploration 50: Project 2: Fixed-Point Numbers
		The fixed Class
			value_type
			places
			places10
			fixed()
			fixed(value_type integer, value_type fraction)
			fixed(double val)
			to_string()
			round()
			integer()
			fraction()
Part III: Generic Programming
	Exploration 51: Function Templates
		Generic Functions
		Using Function Templates
		Writing Function Templates
		Template Parameters
		Template Arguments
		Abbreviated Function Templates
		Declarations and Definitions
		Member Function Templates
	Exploration 52: Class Templates
		Parameterizing a Type
		Parameterizing the rational Class
		Using Class Templates
		Overloaded Operators
		Mixing Types
		Template Variables
	Exploration 53: Template Specialization
		Instantiation and Specialization
		Custom Comparators
		Specializing Function Templates
		Traits
	Exploration 54: Partial Template Specialization
		Degenerate Pairs
		Partial Specialization
		Partially Specializing Function Templates
		Value Template Parameters
	Exploration 55: Template Constraints
		Constraining a Function Template
		Constraining a Class Template
		Standard Concepts
			std::equality_comparable
			std::floating_point
			std::integral
			predicate
			std::strict_weak_order
		Iterator Concepts
			std::bidirection_iterator
			std::contiguous_iterator
			std::forward_iterator
			std::indirectly_readable
			std::indirectly_writable
			std::input_iterator
			std::input_or_output_iterator
			std::output_iterator
			std::permutable
			std::random_access_iterator
			std::sortable
		Range Concepts
			std::ranges::bidirectional_range
			std::ranges::contiguous_range
			std::ranges::forward_range
			std::ranges::input_range
			std::ranges::output_range
			std::ranges::random_access_range
			std::ranges::range
			std::ranges::sized_range
			std::ranges::view
		Writing Your Own Concept
	Exploration 56: Names and Namespaces
		Namespaces
		Nested Namespaces
		Global Namespace
		The std Namespace
		Using Namespaces
			Namespace Alias
			The using Directive
			The using Declaration
			The using Declaration in a Class
		Name Lookup
	Exploration 57: Containers
		Properties of Containers
		Member Types
			value_type
			key_type
			reference
			const_reference
			iterator
			const_iterator
			size_type
		What Can Go into a Container
		Inserting and Erasing
			Inserting in a Sequence Container
			Erasing from a Sequence Container
			Inserting in an Associative Container
			Erasing from an Associative Container
			Exceptions
		Iterators and References
		Sequence Containers
			The array Class Template
			The deque Class Template
			The list Class Template
			The vector Class Template
		Associative Containers
	Exploration 58: Locales and Facets
		The Problem
		Locales to the Rescue
		Locales and I/O
		Facets
		Character Categories
		Collation Order
	Exploration 59: International Characters
		Why Wide?
		Using Wide Characters
		Wide Strings
		Wide Character I/O
		Multi-byte Character Sets
		Unicode
		Universal Character Names
		Unicode Difficulties
	Exploration 60: Text I/O
		File Modes
		String Streams
		Text Conversion
	Exploration 61: Project 3: Currency Type
Part IV: Real Programming
	Exploration 62: Pointers
		A Programming Problem
		The Solution
		Addresses vs. Pointers
		Dependency Graphs
	Exploration 63: Regular Expressions
		Parsing with Regular Expressions
	Exploration 64: Moving Data with Rvalue References
		Copying vs. Moving
		Lvalues, Rvalues, and More
		Implementing Move
		Rvalue or Lvalue?
		Special Member Functions
	Exploration 65: Smart Pointers
		Pointers and Iterators
		More About unique_ptr
		Copyable Smart Pointers
		Smart Arrays
		Pimpls
		Dumb Arrays
	Exploration 66: Files and File Names
		Portable File Names
		Working with Files
		Errors
		Navigating Directories
	Exploration 67: Working with Bits
		Integer As a Set of Bits
		Bitmasks
		Shifting Bits
		Safe Shifting with Unsigned Types
			Signed and Unsigned Types
			Unsigned Literals
			Type Conversions
		Overflow
		Rotating Integers
		Introducing Bitfields
		Portability
		The bitset Class Template
	Exploration 68: Enumerations
		Scoped Enumerations
		Unscoped Enumerations
		Strings and Enumerations
		Spaceships
		Revisiting Projects
	Exploration 69: Multiple Inheritance
		Multiple Base Classes
		Virtual Base Classes
		Java-Like Interfaces
		Interfaces vs. Templates
		Mix-Ins
			Protected Access Level
	Exploration 70: Concepts, Traits, and Policies
		Case Study: Iterators
		Type Traits
		Case Study: char_traits
		Policy-Based Programming
	Exploration 71: Names, Namespaces, and Templates
		Common Rules
		Name Lookup in Templates
		Three Kinds of Name Lookup
		Member Access Operators
		Qualified Name Lookup
		Unqualified Name Lookup
		Argument-Dependent Lookup
	Exploration 72: Overloaded Functions and Operators
		Type Conversion
		Review of Overloaded Functions
		Overload Resolution
			Ranking Functions
			List Initialization
			Tie-Breakers
		Default Arguments
	Exploration 73: Programming at Compile Time
		Compile-Time Functions
		Compile-Time Variables
		Variable-Length Template Argument Lists
		User-Defined Literals
		Types As Values
		Conditional Types
		Substitution Failure Is Not An Error (SFINAE)
	Exploration 74: Project 4: Calculator
Index