book

C++20 for Programmers: An Objects-Natural Approach, 3rd Edition

by Paul Deitel, Harvey Deitel

April 2022

Intermediate to advanced

1012 pages

38h 1m

English

Pearson

Read now

Unlock full access

Includes

Has Sandbox

P.1 Modern C++P.2 Target AudiencesP.3 Live-Code Approach and Getting the CodeP.4 Three Industrial-Strength CompilersP.6 “Objects-Natural” Learning ApproachP.7 A Tour of the BookP.8 How to Get the Online Chapters and AppendicesP.9 C++ Core GuidelinesP.10 Industrial-Strength Static Code Analysis ToolsP.11 Teaching ApproachP.12 Developer ResourcesP.13 DockerP.14 Some Key C++ Documentation and ResourcesP.15 Getting Your Questions AnsweredP.16 Join the Deitel & Associates, Inc. Social Media CommunitiesP.17 Deitel Pearson Products on O’Reilly Online LearningP.18 Live Instructor-Led Training with Paul DeitelP.19 College Textbook Version of C++20 for ProgrammersP.20 AcknowledgmentsAbout the AuthorsAbout Deitel® & Associates, Inc.
Font and Naming ConventionsObtaining the Code ExamplesCompilers We Use in C++20 for ProgrammersSome Examples Do Not Compile and Run on All Three CompilersInstalling Visual Studio Community Edition on WindowsInstalling Xcode on macOSInstalling the Most Recent GNU C++ VersionInstalling the GNU Compiler Collection in Ubuntu Linux Running on the Windows Subsystem for LinuxDocker and Docker ContainersGetting Your C++ Questions AnsweredOnline C++ DocumentationA Note Regarding the {fmt} Text-Formatting LibraryStatic Code Analysis Tools
1.1 Introduction1.2 Test-Driving a C++20 Application1.3 Moore’s Law, Multi-Core Processors and Concurrent Programming1.4 A Brief Refresher on Object Orientation1.5 Wrap-Up

2.1 Introduction2.2 First Program in C++: Displaying a Line of Text2.3 Modifying Our First C++ Program2.4 Another C++ Program: Adding Integers2.5 Arithmetic2.6 Decision Making: Equality and Relational Operators2.7 Objects Natural: Creating and Using Objects of Standard-Library Class string2.8 Wrap-Up
3.1 Introduction3.2 Control Structures3.3 if Single-Selection Statement3.4 if…else Double-Selection Statement3.5 while Iteration Statement3.6 Counter-Controlled Iteration3.7 Sentinel-Controlled Iteration3.8 Nested Control Statements3.9 Compound Assignment Operators3.10 Increment and Decrement Operators3.11 Fundamental Types Are Not Portable3.12 Objects-Natural Case Study: Arbitrary-Sized Integers3.13 C++20: Text Formatting with Function format3.14 Wrap-Up
4.1 Introduction4.2 Essentials of Counter-Controlled Iteration4.3 for Iteration Statement4.4 Examples Using the for Statement4.5 Application: Summing Even Integers4.6 Application: Compound-Interest Calculations4.7 do…while Iteration Statement4.8 switch Multiple-Selection Statement4.9 C++17 Selection Statements with Initializers4.10 break and continue Statements4.11 Logical Operators4.12 Confusing the Equality (==) and Assignment (=) Operators4.13 Objects-Natural Case Study: Using the miniz-cpp Library to Write and Read ZIP files4.14 C++20 Text Formatting with Field Widths and Precisions4.15 Wrap-Up
5.1 Introduction5.2 C++ Program Components5.3 Math Library Functions5.4 Function Definitions and Function Prototypes5.5 Order of Evaluation of a Function’s Arguments5.6 Function-Prototype and Argument-Coercion Notes5.7 C++ Standard Library Headers5.8 Case Study: Random-Number Generation5.9 Case Study: Game of Chance; Introducing Scoped enums5.10 Scope Rules5.11 Inline Functions5.12 References and Reference Parameters5.13 Default Arguments5.14 Unary Scope Resolution Operator5.15 Function Overloading5.16 Function Templates5.17 Recursion5.18 Example Using Recursion: Fibonacci Series5.19 Recursion vs. Iteration5.20 Lnfylun Lhqtomh Wjtz Qarcv: Qjwazkrplm xzz Xndmwwqhlz5.21 Wrap-Up
6.1 Introduction6.2 arrays6.3 Declaring arrays6.4 Initializing array Elements in a Loop6.5 Initializing an array with an Initializer List6.6 C++11 Range-Based for and C++20 Range-Based for with Initializer6.7 Calculating array Element Values and an Intro to constexpr6.8 Totaling array Elements6.9 Using a Primitive Bar Chart to Display array Data Graphically6.10 Using array Elements as Counters6.11 Using arrays to Summarize Survey Results6.12 Sorting and Searching arrays6.13 Multidimensional arrays6.14 Intro to Functional-Style Programming6.15 Objects-Natural Case Study: C++ Standard Library Class Template vector6.16 Wrap-Up
7.1 Introduction7.2 Pointer Variable Declarations and Initialization7.3 Pointer Operators7.4 Pass-by-Reference with Pointers7.5 Built-In Arrays7.6 Using C++20 to_array to Convert a Built-In Array to a std::array7.7 Using const with Pointers and the Data Pointed To7.8 sizeof Operator7.9 Pointer Expressions and Pointer Arithmetic7.10 Objects-Natural Case Study: C++20 spans—Views of Contiguous Container Elements7.11 A Brief Intro to Pointer-Based Strings7.12 Looking Ahead to Other Pointer Topics7.13 Wrap-Up
8.1 Introduction8.2 string Assignment and Concatenation8.3 Comparing strings8.4 Substrings8.5 Swapping strings8.6 string Characteristics8.7 Finding Substrings and Characters in a string8.8 Replacing and Erasing Characters in a string8.9 Inserting Characters into a string8.10 C++11 Numeric Conversions8.11 C++17 string_view8.12 Files and Streams8.13 Creating a Sequential File8.14 Reading Data from a Sequential File8.15 C++14 Reading and Writing Quoted Text8.16 Updating Sequential Files8.17 String Stream Processing8.18 Raw String Literals8.19 Objects-Natural Case Study: Reading and Analyzing a CSV File Containing Titanic Disaster Data8.20 Objects-Natural Case Study: Intro to Regular Expressions8.21 Wrap-Up
9.1 Introduction9.2 Test-Driving an Account Object9.3 Account Class with a Data Member and Set and Get Member Functions9.4 Account Class: Custom Constructors9.5 Software Engineering with Set and Get Member Functions9.6 Account Class with a Balance9.7 Time Class Case Study: Separating Interface from Implementation9.8 Compilation and Linking Process9.9 Class Scope and Accessing Class Members9.10 Access Functions and Utility Functions9.11 Time Class Case Study: Constructors with Default Arguments9.12 Destructors9.13 When Constructors and Destructors Are Called9.14 Time Class Case Study: A Subtle Trap —Returning a Reference or a Pointer to a private Data Member9.15 Default Assignment Operator9.16 const Objects and const Member Functions9.17 Composition: Objects as Members of Classes9.18 friend Functions and friend Classes9.19 The this Pointer9.20 static Class Members: Classwide Data and Member Functions9.21 Aggregates in C++209.22 Objects-Natural Case Study: Serialization with JSON9.23 Wrap-Up
10.1 Introduction10.2 Base Classes and Derived Classes10.3 Relationship Between Base and Derived Classes10.4 Constructors and Destructors in Derived Classes10.5 Intro to Runtime Polymorphism: Polymorphic Video Game10.6 Relationships Among Objects in an Inheritance Hierarchy10.7 Virtual Functions and Virtual Destructors10.8 Abstract Classes and Pure virtual Functions10.9 Case Study: Payroll System Using Runtime Polymorphism10.10 Runtime Polymorphism, Virtual Functions and Dynamic Binding “Under the Hood“10.11 Non-Virtual Interface (NVI) Idiom10.12 Program to an Interface, Not an Implementation10.13 Runtime Polymorphism with std::variant and std::visit10.14 Multiple Inheritance10.15 protected Class Members: A Deeper Look10.16 public, protected and private Inheritance10.17 More Runtime Polymorphism Techniques; Compile-Time Polymorphism10.18 Wrap-Up
11.1 Introduction11.2 Using the Overloaded Operators of Standard Library Class string11.3 Operator Overloading Fundamentals11.4 (Downplaying) Dynamic Memory Management with new and delete11.5 Modern C++ Dynamic Memory Management: RAII and Smart Pointers11.6 MyArray Case Study: Crafting a Valuable Class with Operator Overloading11.7 C++20 Three-Way Comparison Operator (<=>)11.8 Converting Between Types11.9 explicit Constructors and Conversion Operators11.10 Overloading the Function Call Operator ()11.11 Wrap-Up
12.1 Introduction12.2 Exception-Handling Flow of Control12.3 Exception Safety Guarantees and noexcept12.4 Rethrowing an Exception12.5 Stack Unwinding and Uncaught Exceptions12.6 When to Use Exception Handling12.7 Constructors, Destructors and Exception Handling12.8 Processing new Failures12.9 Standard Library Exception Hierarchy12.10 C++’s Alternative to the finally Block: Resource Acquisition Is Initialization (RAII)12.11 Some Libraries Support Both Exceptions and Error Codes12.12 Logging12.13 Looking Ahead to Contracts12.14 Wrap-Up
13.1 Introduction13.2 Introduction to Containers13.3 Working with Iterators13.4 A Brief Introduction to Algorithms13.5 Sequence Containers13.6 vector Sequence Container13.7 list Sequence Container13.8 deque Sequence Container13.9 Associative Containers13.10 Container Adaptors13.11 bitset Near Container13.12 Optional: A Brief Intro to Big O13.13 Optional: A Brief Intro to Hash Tables13.14 Wrap-Up
14.1 Introduction14.2 Algorithm Requirements: C++20 Concepts14.3 Lambdas and Algorithms14.4 Algorithms14.5 Function Objects (Functors)14.6 Projections14.7 C++20 Views and Functional-Style Programming14.8 Intro to Parallel Algorithms14.9 Standard Library Algorithm Summary14.10 A Look Ahead to C++23 Ranges14.11 Wrap-Up
15.1 Introduction15.2 Custom Class Templates and Compile-Time Polymorphism15.3 C++20 Function Template Enhancements15.4 C++20 Concepts: A First Look15.5 Type Traits15.6 C++20 Concepts: A Deeper Look15.7 Testing C++20 Concepts with static_assert15.8 Creating a Custom Algorithm15.9 Creating a Custom Container and Iterators15.10 Default Arguments for Template Type Parameters15.11 Variable Templates15.12 Variadic Templates and Fold Expressions15.13 Template Metaprogramming15.14 Wrap-Up
16.1 Introduction16.2 Compilation and Linking Before C++2016.3 Advantages and Goals of Modules16.4 Example: Transitioning to Modules—Header Units16.5 Modules Can Reduce Translation Unit Sizes and Compilation Times16.6 Example: Creating and Using a Module16.7 Global Module Fragment16.8 Separating Interface from Implementation16.9 Partitions16.10 Additional Modules Examples16.11 Migrating Code to Modules16.12 Future of Modules and Modules Tooling16.13 Wrap-Up
17.1 Introduction17.2 Standard Library Parallel Algorithms (C++17)17.3 Multithreaded Programming17.4 Launching Tasks with std::jthread17.5 Producer–Consumer Relationship: A First Attempt17.6 Producer–Consumer: Synchronizing Access to Shared Mutable Data17.7 Producer–Consumer: Minimizing Waits with a Circular Buffer17.8 Readers and Writers17.9 Cooperatively Canceling jthreads17.10 Launching Tasks with std::async17.11 Thread-Safe, One-Time Initialization17.12 A Brief Introduction to Atomics17.13 Coordinating Threads with C++20 Latches and Barriers17.14 C++20 Semaphores17.15 C++23: A Look to the Future of C++ Concurrency17.16 Wrap-Up
18.1 Introduction18.2 Coroutine Support Libraries18.3 Installing the concurrencpp and generator Libraries18.4 Creating a Generator Coroutine with co_yield and the generator Library18.5 Launching Tasks with concurrencpp18.6 Creating a Coroutine with co_await and co_return18.7 Low-Level Coroutines Concepts18.8 C++23 Coroutines Enhancements18.9 Wrap-Up
19.1 Introduction19.2 Streams19.3 Stream Output19.4 Stream Input19.5 Unformatted I/O Using read, write and gcount19.6 Stream Manipulators19.7 Stream Error States19.8 Tying an Output Stream to an Input Stream19.9 C++20 Text Formatting19.10 Wrap-Up
20.1 Introduction20.2 const_cast Operator20.3 Storage Classes and Storage Duration20.4 namespaces20.5 Operator Keywords20.6 Pointers to Class Members (.* and ->*)20.7 Case Study: Payroll System Using Polymorphism and Runtime Type Information — Downcasting, dynamic_cast, typeid and type_info20.8 Inheriting Base-Class Constructors20.9 C++17 and C++20: [[nodiscard]] Attribute20.10 shared_ptr and weak_ptr Smart Pointers20.11 Trailing Return Types for Functions20.12 decltype20.13 initializer_list Class Template20.14 C++20: [[likely]] and [[unlikely]] Attributes20.15 A Look Toward C++2320.16 Wrap-Up20.17 Closing Notes
C.1 IntroductionC.2 Abbreviating Binary Numbers as Octal and Hexadecimal NumbersC.3 Converting Octal and Hexadecimal Numbers to Binary NumbersC.4 Converting from Binary, Octal or Hexadecimal to DecimalC.5 Converting from Decimal to Binary, Octal or HexadecimalC.6 Negative Binary Numbers: Two’s Complement Notation
D.1 IntroductionD.2 #include Preprocessing DirectiveD.3 #define Preprocessing Directive: Symbolic ConstantsD.4 #define Preprocessing Directive: MacrosD.5 Conditional CompilationD.6 #error and #pragma Preprocessing DirectivesD.7 Operators # and ##D.8 Predefined Symbolic ConstantsD.9 Assertions
E.1 IntroductionE.2 Bitwise OperatorsE.3 Bit Fields

Content preview from C++20 for Programmers: An Objects-Natural Approach, 3rd Edition

B. Character Set

ASCII Character Set
`0`	`1`	`2`	`3`	`4`	`5`	`6`	`7`	`8`	`9`
`0`	`nul`	`soh`	`stx`	`etx`	`eot`	`enq`	`ack`	`bel`	`bs`	`ht`
`1`	`nl`	`vt`	`ff`	`cr`	`so`	`si`	`dle`	`dc1`	`dc2`	`dc3`
`2`	`dc4`	`nak`	`syn`	`etb`	`can`	`em`	`sub`	`esc`	`fs`	`gs`
`3`	`rs`	`us`	`sp`	`!`	`"`	`#`	`$`	`%`	`&`	`‘`
`4`	`(`	`)`	`*`	`+`	`,`	`-`	`.`	`/`	`0`	`1`
`5`	`2`	`3`	`4`	`5`	`6`	`7`	`8`	`9`	`:`	`;`
`6`	`<`	`=`	`>`	`?`	`@`	`A`	`B`	`C`	`D`	`E`
`7`	`F`	`G`	`H`	`I`	`J`	`K`	`L`	`M`	`N`	`O`
`8`	`P`	`Q`	`R`	`S`	`T`	`U`	`V`	`W`	`X`	`Y`
`9`	`Z`	`[`	`\`	`]`	`^`	`_`	`’`	`a`	`b`	`c`
`10`	`d`	`e`	`f`	`g`	`h`	`i`	`j`	`k`	`l`	`m`
`11`	`n`	`o`	`p`	`q`	`r`	`s`	`t`	`u`	`v`	`w`
`12`	`x`	`y`	`z`	`{`	`\|`	`}`	`~`	`del`

The digits at the left of the table are the left digits of the decimal equivalents (0–127) of the character codes, and the digits at the top of the table are the right digits of the character codes. For example, the character code for “F” is 70, and the character code for “&” is 38.