book

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

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

by Paul Deitel, Harvey Deitel

April 2022

Intermediate to advanced

1012 pages

38h 1m

English

Pearson

Read now

Unlock full access

Includes

Sandbox

Cover Page
About This eBook
Halftitle Page
Title Page
Copyright Page
Dedication Page
Contents
Preface
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.
Before You Begin
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. Intro and Test-Driving Popular, Free C++ Compilers
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. Intro to C++20 Programming
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. Control Statements: Part 1
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. Control Statements: Part 2
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. Functions and an Intro to Function Templates
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. arrays, vectors, Ranges and Functional-Style Programming
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. (Downplaying) Pointers in Modern C++
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. strings, string_views, Text Files, CSV Files and Regex
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. Custom Classes
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. OOP: Inheritance and Runtime Polymorphism
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. Operator Overloading, Copy/Move Semantics and Smart Pointers
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. Exceptions and a Look Forward to Contracts
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. Standard Library Containers and Iterators
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. Standard Library Algorithms and C++20 Ranges & Views
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. Templates, C++20 Concepts and Metaprogramming
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. C++20 Modules: Large-Scale Development
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. Parallel Algorithms and Concurrency: A High-Level View
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. C++20 Coroutines
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
A. Operator Precedence and Grouping
B. Character Set
Index
19. Stream I/O & C++20 Text Formatting
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. Other Topics and a Look Toward the Future of C++
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. Number Systems
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. Preprocessor
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. Bit Manipulation
E.1 IntroductionE.2 Bitwise OperatorsE.3 Bit Fields
Code Snippets

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

12. Exceptions and a Look Forward to Contracts

Objectives

In this chapter, you’ll:

Understand the exception-handling flow of control with try, catch and throw.
Provide exception guarantees for your code.
Understand the standard library exception hierarchy.
Define a custom exception class.
Understand how stack unwinding enables exceptions not caught in one scope to be caught in an enclosing scope.
Handle dynamic memory allocation failures.
Catch exceptions of any type with catch(...).
Understand what happens with uncaught exceptions.
Understand which exceptions should not be handled and which cannot be handled.
Understand why some organizations disallow exceptions and the impact that can have on software development efforts.
Understand the ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780136905776

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

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

by Paul Deitel, Harvey Deitel

12. Exceptions and a Look Forward to Contracts

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.