- Артикул:00-01120632
- Автор: Patrice Roy
- ISBN: 978-1-80512-980-6
- Обложка: Мягкая обложка
- Издательство: Packt (все книги издательства)
- Город: UK
- Страниц: 433
- Год: 2025
- Вес: 1093 г
Развернуть ▼
Издание на английском языке
This book is an in-depth and accessible guide to memory management in C++, covering key concepts such as objects, pointers, references, object lifecycles, alignment, and the risks of memory leaks. It explores complex topics through a balance of theory and practice to help developers write safe and efficient code. You'll learn how to use modern techniques-smart pointers, RAII, types, and casts - to properly manage resources and prevent errors. This book is designed for all levels - from beginners to experienced professionals-who want to deepen their knowledge and create reliable, clean, and optimized C++ code.
Content
Preface
Part 1: Memory in C++
1. Objects, Pointers, and References
Technical requirements
Representation of memory in C++
Objects, pointers, and references
Understanding the fundamental properties of objects
Object lifetime
Object size, alignment, and padding
Copy and movement
Arrays
Summary
2. Things to Be Careful With
Different kinds of evil
Ill-formed, no diagnostic required
Undefined behavior
Implementation-defined behavior
Unspecified behavior (not documented)
The ODR
Erroneous behavior
Pointers
Uses of pointer arithmetic within an array
Pointer interconvertibility
Uses of pointer arithmetic within an object
Type punning
Type punning through members of a union
The intptr t and uintptr t types
The std::memcpy function
The special cases of char, unsigned char, and std::byte
The std::start lifetime as "T" function
Summary
3. Casts and cv-qualifications
Technical requirements
What is a cast?
Safety in the type system - cv - qualifications
The C++ casts
Your best friend (most of the time) - static cast
A sign something's wrong - dynamic cast
Playing tricks with safety - const cast
"Believe me, compiler" - reinterpret cast
I know the bits are right - bit cast
Somewhat unrelated, but still - duration cast
The reviled one - the C cast
Summary
Part 2: Implicit Memory Management Techniques
4. Using Destructors
Technical requirements
On destructors: a short recap
Managing resources
Exception handling... or not?
The RAII idiom
RAII and C++'s special member functions
Some pitfalls
Destructors should not throw
Know thy destruction order
Standard resource management automation tools
Unique ptr "T" and shared ptr "T"
Lock guard and scoped lock
stream objects
vector "T" and other containers
Summary
5. Using Standard Smart Pointers
Technical requirements
The standard smart pointers
On the exposition of intent through function signatures
Type unique ptr
Handling objects
Handling arrays
Custom deleters
Make unique
Types shared ptr and weak ptr
Usefulness and costs
Make shared
What about weak ptr?
When to use raw pointers
Summary
6. Writing Smart Pointers
Technical requirements
Ownership semantics
Writing your own (naive) unique ptr
Type signature
Special member functions
Pointer-like functions
Writing your own (naive) shared ptr
A few words on make shared
Writing a policy-based duplicating pointer
Detection through interfaces
Detection through traits
Detection through concepts
Some not-so-smart yet useful smart pointers
A non null ptr type
An observer ptr type
Summary
Part 3: Taking Control (of Memory Management Mechanisms)
7. Overloading Memory Allocation Operators
Why would one overload allocation functions?
Brief overview of the C language allocation functions
Overview of the C++ allocation operators
Global allocation operators
Non-throwing versions of the allocation operators
The most important operator new: placement new
Member versions of the allocation operators
Alignment-aware versions of the allocation operators
Destroying delete
Summary
8. Writing a Naive Leak Detector
Technical requirements
The plan
A first implementation (that almost works)
The Accountant singleton class
Implementing the new and new operators
Implementing the delete and delete operators
Visualizing it all
Identifying (and fixing) the problems
Revisiting our implementation (and lessons learned)
Summary
9. Atypical Allocation Mechanisms
Technical requirements
Placement new and memory-mapped hardware
Simplifying nothrow new usage
Out-of-memory situations and new handler
Standard C++ and exotic memory
A fictional shared memory API
A handmade user code example
A standard-looking user code equivalent
Summary
10. Arena-Based Memory Management and Other Optimizations
Technical requirements
Arena-based memory management
Specific example - size-based implementation
Generalizing to Size Based Arena "T, N"
When parameters change
Chunked pools
Summary
11. Deferred Reclamation
Technical requirements
What do we mean by deferred reclamation?
Reclamation (without finalization) at the end of the program
Reclamation and finalization at the end of the program
Reclamation and finalization at the end of the scope
Summary
Part 4: Writing Generic Containers (and a Bit More)
12. Writing Generic Containers with Explicit Memory Management
Technical requirements
Writing your own vector "T" alternative
Representational choices for a container of contiguous elements
The implementation of Vector "T"
Writing your own forward list "T" alternative
Representational choices for a node-based container
The implementation of Forward List "T"
Better memory management
A more efficient Vector "T"
Using low-level standard facilities
Const or reference members and std::launder
Summary
13. Writing Generic Containers with Implicit Memory Management
Technical requirements
Why explicit memory management complicates our implementation
Implicit memory management with a smart pointer
Impact on the naive Vector "T" implementation
Impact on the sophisticated Vector "T" implementation
Consequences of this redesign
Generalizing to Forward List "T"?
Attempt - making each node responsible for its successor
Attempt: making the head pointer responsible for the other nodes
Summary
14. Writing Generic Containers with Allocator Support
Technical requirements
Why allocators?
Traditional allocators
Before C++11
Traditional allocators with contemporary standards
Managing traditional allocator lifetime
Irritants with traditional allocators
Polymorphic memory resource allocators
Nested allocators
Allocators and data collection
Upsides and costs
Summary
15. Contemporary Issues
Technical requirements
Starting object
lifetime without constructors
Trivial relocation
Type-aware allocation and deallocation functions
Summary
Annexure
Things You Should Know
struct and class
std::size t
The size of operator
Assertions
Undefined behavior
Type traits
The std::true type and std::false type traits
The std::conditional "B, T ,F" trait
Algorithms
Functors (function objects) and lambdas
Friends
The decltype operator
Perfect forwarding
The singleton design pattern
Instantiation at program startup
Instantiation of the first call
The std::exchange function
Index
Other Books You May Enjoy