book

C++

Name: C++
ISBN: 9781806100576

by Rheinwerk Publishing, Inc, Torsten T. Will

June 2025

Intermediate to advanced

1093 pages

33h 24m

English

Packt Publishing

Read now

Unlock full access

Notes on Usage
Table of Contents
Preface
Part I Fundamentals
1 C++: The Comprehensive Guide
1.1 New and Modern
1.2 “Dan” Chapters
1.3 Presentation in This Book
1.4 Formatting Used
1.5 Let’s Talk Lingo
2 Programming in C++
2.1 Compiling

2.2 Translation Phases
2.3 Current Compilers
2.3.1 Gnu C++2.3.2 Clang++ from LLVM2.3.3 Microsoft Visual C++2.3.4 Compiler in the Container
2.4 Development Environments
2.5 The Command Line under Ubuntu
2.5.1 Create a Program2.5.2 Automate with Makefile
2.6 The Visual Studio Code IDE under Windows
2.7 Speed Up the Sample Program
3 C++ for Newcomers
4 The Basic Building Blocks of C++
4.1 A Quick Overview4.1.1 Comments4.1.2 The “include” Directive4.1.3 The Standard Library4.1.4 The “main()” Function4.1.5 Types4.1.6 Variables4.1.7 Initialization4.1.8 Output on the Console4.1.9 Statements
4.2 A Detailed Walkthrough
4.2.1 Spaces, Identifiers, and Tokens4.2.2 Comments4.2.3 Functions and Arguments4.2.4 Side Effect Operators4.2.5 The “main” Function4.2.6 Statements4.2.7 Expressions4.2.8 Allocations4.2.9 Types4.2.10 Variables: Declaration, Definition, and Initialization4.2.11 Initialize with “auto”4.2.12 Details on the Include Directive4.2.13 Modules4.2.14 Input and Output4.2.15 The “std” Namespace
4.3 Operators
4.3.1 Operators and Operands4.3.2 Overview of Operators4.3.3 Arithmetic Operators4.3.4 Bit-by-Bit Arithmetic4.3.5 Composite Assignment4.3.6 Post- and Preincrement and Post- and Predecrement4.3.7 Relational Operators4.3.8 Logical Operators4.3.9 Pointer and Dereference Operators4.3.10 Special Operators4.3.11 Function-Like Operators4.3.12 Operator Sequence
4.4 Built-In Data Types
4.4.1 Overview4.4.2 Initialize Built-In Data Types4.4.3 Integers4.4.4 Floating-Point Numbers4.4.5 Truth Values4.4.6 Character Types4.4.7 Complex Numbers
4.5 Undefined Behavior
5 Good Code, 1st Dan: Writing Readable Code
5.1 Comments
5.2 Documentation
5.3 Indentations and Line Length
5.4 Lines per Function and File
5.5 Brackets and Spaces
5.6 Names
6 Higher Data Types
6.1 The String Type “string”6.1.1 Initialization6.1.2 Functions and Methods6.1.3 Other String Types6.1.4 For Viewing Only: “string_view”
6.2 Streams
6.2.1 Input and Output Operators6.2.2 “getline”6.2.3 Files for Input and Output6.2.4 Manipulators6.2.5 The “endl” Manipulator
6.3 Container and Pointer
6.3.1 Container6.3.2 Parameterized Types
6.4 The Simple Sequence Containers
6.4.1 “array”6.4.2 “vector”
6.5 Algorithms
6.6 Pointers and C-Arrays
6.6.1 Pointer Types6.6.2 C-Arrays
7 Functions
7.1 Declaration and Definition of a Function
7.2 Function Type
7.3 Using Functions
7.4 Defining a Function
7.5 More about Parameters
7.5.1 Call-by-Value7.5.2 Call-by-Reference7.5.3 Constant References7.5.4 Call as Value, Reference, or Constant Reference?
7.6 Functional Body
7.7 Converting Parameters
7.8 Overloading Functions
7.9 Default Parameter
7.10 Arbitrary Number of Arguments
7.11 Alternative Notation for Function Declaration
7.12 Specialties
7.12.1 “noexcept”7.12.2 Inline Functions7.12.3 “constexpr”7.12.4 Deleted Functions7.12.5 Specialties in Class Methods
8 Statements in Detail
8.1 The Statement Block8.1.1 Standalone Blocks and Variable Scope
8.2 The Empty Statement
8.3 Declaration Statement
8.3.1 Structured Binding
8.4 The Expression Statement
8.5 The “if” Statement
8.5.1 “if” with Initializer8.5.2 Compile-Time “if”
8.6 The “while” Loop
8.7 The “do-while” Loop
8.8 The “for” Loop
8.9 The Range-Based “for” Loop
8.10 The “switch” Statement
8.11 The “break” Statement
8.12 The “continue” Statement
8.13 The “return” Statement
8.14 The “goto” Statement
8.15 The “try-catch” Block and “throw”
8.16 Summary
9 Expressions in Detail
9.1 Calculations and Side Effects
9.2 Types of Expressions
9.3 Literals
9.4 Identifiers
9.5 Parentheses
9.6 Function Call and Index Access
9.7 Assignment
9.8 Type Casting
10 Error Handling
10.1 Error Handling with Error Codes
10.2 What Is an Exception?
10.2.1 Throwing and Handling Exceptions10.2.2 Unwinding the Call Stack
10.3 Minor Error Handling
10.4 Throwing the Exception Again: “rethrow”
10.5 The Order in “catch”
10.5.1 No “finally”10.5.2 Standard Library Exceptions
10.6 Types for Exceptions
10.7 When an Exception Falls Out of “main”
11 Good Code, 2nd Dan: Modularization
11.1 Program, Library, Object File
11.2 Modules
11.3 Separating Functionalities
11.4 A Modular Example Project
11.4.1 Namespaces11.4.2 Implementation11.4.3 Using the Library
Part II Object-Oriented Programming and More
12 From Structure to Class
12.1 Initialization
12.2 Returning Custom Types
12.3 Methods Instead of Functions
12.4 The Better “print”
12.5 An Output Like Any Other
12.6 Defining Methods Inline
12.7 Separate Implementation and Definition
12.8 Initialization via Constructor
12.8.1 Member Default Values in Declaration12.8.2 Constructor Delegation12.8.3 Default Values for Constructor Parameters12.8.4 Do Not Call the “init” Method in the Constructor12.8.5 Exceptions in the Constructor
12.9 Struct or Class?
12.9.1 Encapsulation12.9.2 “public” and “private”, Struct and Class12.9.3 Data with “struct”, Behavior with “class”12.9.4 Initialization of Types with Private Data
12.10 Interim Recap
12.11 Using Custom Data Types
12.11.1 Using Classes as Values12.11.2 Using Constructors12.11.3 Type Conversions12.11.4 Encapsulate and Decapsulate12.11.5 Give Types a Local Name
12.12 Type Inference with “auto”
12.13 Custom Classes in Standard Containers
12.13.1 Three-Way Comparison: The Spaceship Operator
13 Namespaces and Qualifiers
13.1 The “std” Namespace
13.2 Anonymous Namespace
13.3 “static” Makes Local
13.4 “static” Likes to Share
13.5 Remote Initialization or “static inline” Data Fields
13.6 Guaranteed to Be Initialized at Compile Time with “constinit”
13.7 “static” Makes Permanent
13.8 “inline namespace”
13.9 Interim Recap
13.10 “const”
13.10.1 Const Parameters13.10.2 Const Methods13.10.3 “const” Variables13.10.4 Const Returns13.10.5 “const” Together with “static”13.10.6 Even More Constant with “constexpr”13.10.7 “if constexpr” for Compile-Time Decisions13.10.8 C++20: “consteval”13.10.9 “if consteval”13.10.10 Un-“const” with “mutable”13.10.11 Const-Correctness13.10.12 Summary
13.11 Volatile with “volatile”
14 Good Code, 3rd Dan: Testing
14.1 Types of Tests14.1.1 Refactoring14.1.2 Unit Tests14.1.3 Social or Solitary14.1.4 Doppelgangers14.1.5 Suites
14.2 Frameworks
14.2.1 Arrange, Act, Assert14.2.2 Frameworks to Choose From
14.3 Boost.Test
14.4 Helper Macros for Assertions
14.5 An Example Project with Unit Tests
14.5.1 Private and Public Testing14.5.2 An Automatic Test Module14.5.3 Compile Test14.5.4 Assemble the Test Suite Yourself14.5.5 Testing Private Members14.5.6 Parameterized Tests
15 Inheritance
15.1 Relationships15.1.1 Has-a Composition15.1.2 Has-a Aggregation15.1.3 Is-a Inheritance15.1.4 Instance-of versus Is-a Relationship
15.2 Inheritance in C++
15.3 Has-a versus Is-a
15.4 Finding Commonalities
15.5 Derived Types Extend
15.6 Overriding Methods
15.7 How Methods Work
15.8 Virtual Methods
15.9 Constructors in Class Hierarchies
15.10 Type Conversion in Class Hierarchies
15.10.1 Converting Up the Inheritance Hierarchy15.10.2 Downcasting the Inheritance Hierarchy15.10.3 References Also Retain Type Information
15.11 When to Use Virtual?
15.12 Other Designs for Extensibility
16 The Lifecycle of Classes
16.1 Creation and Destruction
16.2 Temporary: Short-Lived Values
16.3 The Destructor to the Constructor
16.3.1 No Destructor Needed16.3.2 Resources in the Destructor
16.4 Yoda Condition
16.5 Construction, Destruction, and Exceptions
16.6 Copy
16.7 Assignment Operator
16.8 Removing Methods
16.9 Move Operations
16.9.1 What the Compiler Generates
16.10 Operators
16.11 Custom Operators in a Data Type
16.12 Special Class Forms
16.12.1 Abstract Classes and Methods16.12.2 Enumeration Classes
17 Good Code, 4th Dan: Security, Quality, and Sustainability
17.1 The Rule of Zero17.1.1 The Big Five17.1.2 Helper Construct by Prohibition17.1.3 The Rule of Zero and Its Application17.1.4 Exceptions to the Rule of Zero17.1.5 Rule of Zero, Rule of Three, Rule of Five, Rule of Four and a Half
17.2 Resource Acquisition Is Initialization
17.2.1 An Example with C17.2.2 Owning Raw Pointers17.2.3 From C to C++17.2.4 It Doesn't Always Have to Be an Exception17.2.5 Multiple Constructors17.2.6 Multiphase Initialization17.2.7 Define Where It Is Needed17.2.8 “new” without Exceptions
18 Specials for Classes
18.1 Allowed to See Everything: “friend” Classes18.1.1 “friend class” Example
18.2 Nonpublic Inheritance
18.2.1 Impact on the Outside World18.2.2 Nonpublic Inheritance in Practice
18.3 Signature Classes as Interfaces
18.4 Multiple Inheritance
18.4.1 Multiple Inheritance in Practice18.4.2 Caution with Pointer Type Conversions18.4.3 The Observer Pattern as a Practical Example
18.5 Diamond-Shaped Multiple Inheritance: “virtual” for Class Hierarchies
18.6 Literal Data Types: “constexpr” for Constructors
19 Good Code, 5th Dan: Classical Object-Oriented Design
19.1 Objects in C++
19.2 Object-Oriented Design
19.2.1 SOLID19.2.2 Don't Be STUPID
Part III Advanced Topics
20 Pointers
20.1 Addresses
20.2 Pointer
20.3 Dangers of Aliasing
20.4 Heap Memory and Stack Memory
20.4.1 The Stack20.4.2 The Heap
20.5 Smart Pointers
20.5.1 “unique_ptr”20.5.2 “shared_ptr”
20.6 Raw Pointers
20.7 C-Arrays
20.7.1 Calculating with Pointers20.7.2 Decay of C-Arrays20.7.3 Dynamic C-Arrays20.7.4 String Literals
20.8 Iterators
20.9 Pointers as Iterators
20.10 Pointers in Containers
20.11 The Exception: When Cleanup Is Not Necessary
21 Macros
21.1 The Preprocessor
21.2 Beware of Missing Parenthesis
21.3 Feature Macros
21.4 Information about the Source Code
21.5 Warning about Multiple Executions
21.6 Type Variability of Macros
21.7 Summary
22 Interface to C
22.1 Working with Libraries
22.2 C Header
22.3 C Resources
22.4 “void” Pointers
22.5 Reading Data
22.6 The Main Program
22.7 Summary
23 Templates
23.1 Function Templates23.1.1 Overloading23.1.2 A Type as Parameter23.1.3 Function Body of a Function Template23.1.4 Values as Template Parameters23.1.5 Many Functions23.1.6 Parameters with Extras23.1.7 Method Templates are Just Function Templates
23.2 Function Templates in the Standard Library
23.2.1 Ranges instead of Containers as Template Parameters23.2.2 Example: Information about Numbers
23.3 A Class as a Function
23.3.1 Values for a “Function” Parameter23.3.2 C Function Pointer23.3.3 The Somewhat Different Function23.3.4 Practical Functors23.3.5 Algorithms with Functors23.3.6 Anonymous Functions: a.k.a. Lambda Expressions23.3.7 Template Functions without “template”, but with “auto”
23.4 C++ Concepts
23.4.1 How to Read Concepts23.4.2 How to Use Concepts23.4.3 How to Write Concepts23.4.4 Semantic Constraints23.4.5 Interim Recap
23.5 Template Classes
23.5.1 Implementing Class Templates23.5.2 Implementing Methods of Class Templates23.5.3 Creating Objects from Class Templates23.5.4 Class Templates with Multiple Formal Data Types23.5.5 Class Templates with Nontype Parameters23.5.6 Class Templates with Defaults23.5.7 Specializing Class Templates
23.6 Templates with Variable Argument Count
23.6.1 “sizeof ...” Operator23.6.2 Convert Parameter Pack to Tuple
23.7 Custom Literals
23.7.1 What Are Literals?23.7.2 Naming Rules23.7.3 Literal Processing Phases23.7.4 Overloading Variants23.7.5 User-Defined Literal Using Template23.7.6 Raw or Cooked23.7.7 Automatically Merged23.7.8 Unicode Literals
Part IV The Standard Library
24 Containers
24.1 Basics24.1.1 Recurring24.1.2 Abstract24.1.3 Operations24.1.4 Complexity24.1.5 Containers and Their Iterators24.1.6 Ranges Simplify Iterators24.1.7 Ranges, Views, Concepts, Adapters, Generators, and Algorithms24.1.8 Algorithms
24.2 Iterator Basics
24.2.1 Iterators from Containers24.2.2 More Functionality with Iterators
24.3 Allocators: Memory Issues
24.4 Container Commonalities
24.5 An Overview of the Standard Container Classes
24.5.1 Type Aliases of Containers
24.6 The Sequential Container Classes
24.6.1 Commonalities and Differences24.6.2 Methods of Sequence Containers24.6.3 “vector”24.6.4 “array”24.6.5 “deque”24.6.6 “list”24.6.7 “forward_list”
24.7 Associative and Ordered
24.7.1 Commonalities and Differences24.7.2 Methods of Ordered Associative Containers24.7.3 “set”24.7.4 “map”24.7.5 “multiset”24.7.6 “multimap”
24.8 Only Associative and Not Guaranteed
24.8.1 Hash Tables24.8.2 Commonalities and Differences24.8.3 Methods of Unordered Associative Containers24.8.4 “unordered_set”24.8.5 “unordered_map”24.8.6 “unordered_multiset”24.8.7 “unordered_multimap”
24.9 Container Adapters
24.10 Special Cases: “string”, “basic_string”, and “vector<char>”
24.11 Special Cases: “vector<bool>”, “array<bool,n>”, and “bitset<n>”
24.11.1 Dynamic and Compact: “vector<bool>”24.11.2 Static: “array<bool,n>” and “bitset<n>”
24.12 Special Case: Value Array with “valarray<>”
24.12.1 Element Properties24.12.2 Initialize24.12.3 Assignment24.12.4 Insert and Delete24.12.5 Accessing24.12.6 Specialty: Manipulate All Data24.12.7 Specialty: Slicing and Masking
25 Container Support
25.1 Algorithms
25.2 Iterators and Ranges
25.3 Iterator Adapter
25.4 Algorithms of the Standard Library
25.5 Parallel Execution
25.6 Lists of Algorithm Functions and Range Adapters
25.6.1 Range Adapters and Views25.6.2 Ranges as Parameters (and More)25.6.3 List of Nonmodifying Algorithms25.6.4 Inherently Modifying Algorithms25.6.5 Algorithms for Partitions25.6.6 Algorithms for Sorting and Fast Searching in Sorted Ranges25.6.7 Set Algorithms Represented by a Sorted Range25.6.8 Heap Algorithms25.6.9 Minimum and Maximum25.6.10 Various Algorithms
25.7 Element-Linking Algorithms from “<numeric>” and “<ranges>”
25.8 Copy instead of Assignment: Values in Uninitialized Memory Areas
25.9 Custom Algorithms
25.10 Writing Custom Views and Range Adapters
26 Good Code, 6th Dan: The Right Container for Each Task
26.1 All Containers Arranged by Aspects26.1.1 When Is a “vector” Not the Best Choice?26.1.2 Always Sorted: “set”, “map”, “multiset”, and “multimap”26.1.3 In Memory Contiguously: “vector”, “array”26.1.4 Cheap Insertion: “list”26.1.5 Low Memory Overhead: “vector”, “array”26.1.6 Size Dynamic: All Except “array”
26.2 Recipes for Containers
26.2.1 Two Phases? “vector” as a Good “set” Replacement26.2.2 Output the Contents of a Container to a Stream26.2.3 So “array” Is Not That Static
26.3 Implementing Algorithms That Are Specialized Depending on the Container
27 Streams, Files, and Formatting
27.1 Input and Output Concept with Streams
27.2 Global, Predefined Standard Streams
27.2.1 Stream Operators << and >>
27.3 Methods for Stream Input and Output
27.3.1 Methods for Unformatted Output27.3.2 Methods for Unformatted Input
27.4 Error Handling and Stream States
27.4.1 Methods for Handling Stream Errors
27.5 Manipulating and Formatting Streams
27.5.1 Manipulators27.5.2 Creating Custom Manipulators without Arguments27.5.3 Creating Custom Manipulators with Arguments27.5.4 Directly Change Format Flags
27.6 Streams for File Input and Output
27.6.1 The “ifstream”, “ofstream”, and “fstream” Streams27.6.2 Connecting to a File27.6.3 Reading and Writing27.6.4 Random Access27.6.5 Synchronized Streams for Threads
27.7 Streams for Strings
27.7.1 Difference from “to_string”27.7.2 “to_chars” and “format” Are More Flexible than “to_string”27.7.3 Reading from a String
27.8 Stream Buffers
27.8.1 Access to the Stream Buffer of “iostream” Objects27.8.2 “filebuf”27.8.3 “stringbuf”
27.9 “filesystem”
27.10 Formatting
27.10.1 Simple Formatting27.10.2 Formatting Custom Types
28 Standard Library: Extras
28.1 “pair” and “tuple”28.1.1 Returning Multiple Values
28.2 Regular Expressions
28.2.1 Matching and Searching28.2.2 The Result and Parts of It28.2.3 Found Replacement28.2.4 Rich in Variants28.2.5 Iterators28.2.6 Matches28.2.7 Options28.2.8 Speed28.2.9 Standard Syntax, Slightly Shortened28.2.10 Notes on Regular Expressions in C++
28.3 Randomness
28.3.1 Rolling a Die28.3.2 True Randomness28.3.3 Other Generators28.3.4 Distributions
28.4 Mathematical
28.4.1 Fraction and Time: “<ratio>” and “<chrono>”28.4.2 Predefined Suffixes for User-Defined Literals
28.5 System Error Handling with “system_error”
28.5.1 Overview28.5.2 Principles28.5.3 “error_code” and “error_condition”28.5.4 Error Categories28.5.5 Custom Error Codes28.5.6 “system_error” Exception
28.6 Runtime Type Information: “<typeinfo>” and “<typeindex>”
28.7 Helper Classes around Functors: “<functional>”
28.7.1 Function Objects28.7.2 Function Generators
28.8 “optional” for a Single Value or No Value
28.9 “variant” for One of Several Types
28.10 “any” Holds Any Type
28.11 Special Mathematical Functions
28.12 Fast Conversion with “<charconv>”
29 Threads: Programming with Concurrency
29.1 C++ Threading Basics29.1.1 Starting Pure Threads29.1.2 Terminating a Thread Prematurely29.1.3 Waiting for a Thread29.1.4 Consider Exceptions in the Starting Thread29.1.5 Passing Parameters to a Thread Function29.1.6 Moving a Thread29.1.7 How Many Threads to Start?29.1.8 Which Thread Am I?
29.2 Shared Data
29.2.1 Data Races29.2.2 Latch29.2.3 Barriers29.2.4 Mutexes29.2.5 Interface Design for Multithreading29.2.6 Locks Can Lead to Deadlock29.2.7 More Flexible Locking with “unique_lock”
29.3 Other Synchronization Options
29.3.1 Call Only Once with “once_flag” and “call_once”29.3.2 Locking with “recursive_mutex”
29.4 In Its Own Storage with “thread_local”
29.5 Waiting for Events with “condition_variable”
29.5.1 “notify_all”29.5.2 Synchronize Output
29.6 Waiting Once with “future”
29.6.1 Launch Policies29.6.2 Wait Until a Certain Time29.6.3 Exception Handling with “future”29.6.4 “promise”
29.7 Atomics
29.7.1 Overview of the Operations29.7.2 Memory Order29.7.3 Example
29.8 Coroutines
29.8.1 Coroutines in the Compiler29.8.2 Generator29.8.3 Coroutines with “promise_type”
29.9 Summary
29.9.1 “<thread>” Header29.9.2 “<latch>” and “<barrier>” Headers29.9.3 “<mutex>” and “<shared mutex>” Headers29.9.4 “<condition variable>” Header29.9.5 “<future>” Header29.9.6 “<atomic>” Header29.9.7 “<coroutine>” Header
30 Good Code, 7th Dan: Guidelines
30.1 Guideline Support Library
30.2 C++ Core Guidelines
30.2.1 Motivation30.2.2 Type Safety30.2.3 Use RAII30.2.4 Class Hierarchies30.2.5 Generic Programming30.2.6 Do Not Be Confused by Anachronisms
A Cheat Sheet
B The Author
Index
Service Pages
Legal Notes

Content preview from C++

24.3 Allocators: Memory Issues

Containers constantly request new memory to store their elements. This can be a complex task, especially for noncontiguous containers like list or set. To give users the ability to intervene, each container is equipped with an allocator. If you do not specify one, it defaults to std::allocator<Elem>.

[Übung] Allocators Are an Expert Topic

I recommend that you use std::allocator and do not implement your own allocator. If you do, use ones from the Boost project or other major providers. The concept of allocators implemented in the current standard library is much debated and does not make all experts happy. You should not bother delving deeply into this subject unless you really have to.

To show you how to ...

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: 9781806100576

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C++

by Rheinwerk Publishing, Inc, Torsten T. Will

24.3 Allocators: Memory Issues

[Übung] Allocators Are an Expert Topic

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.

More than 5,000 organizations count on O’Reilly

Julian F.

Addison B.

Amir M.

Mark W.

You might also like

C++ Software Design

Introducing C++

C++ Memory Management

Effective Modern C++

Publisher Resources