book

C++ Memory Management

Name: C++ Memory Management
Author: Patrice Roy
ISBN: 9781805129806

by Patrice Roy

March 2025

Intermediate to advanced

442 pages

11h 16m

English

Packt Publishing

Read now

Unlock full access

C++ Memory Management
Foreword
Contributors
About the author
About the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare Your Thoughts
Part 1: Memory in C++
Chapter 1: Objects, Pointers, and References
Getting the most out of this book – get to know your free benefitsInteractive AI assistant (beta)DRM-free PDF or ePub version Technical requirementsRepresentation of memory in C++Objects, pointers, and referencesUnderstanding the fundamental properties of objectsObject lifetimeObject size, alignment, and paddingCopy and movementArraysSummary
Chapter 2: Things to Be Careful With
Different kinds of evilIll-formed, no diagnostic requiredUndefined behaviorImplementation-defined behaviorUnspecified behavior (not documented)The ODRErroneous behaviorPointersUses of pointer arithmetic within an arrayPointer interconvertibilityUses of pointer arithmetic within an objectType punningType punning through members of a unionThe intptr_t and uintptr_t typesThe std::memcpy() functionThe special cases of char*, unsigned char*, and std::byte*The std::start_lifetime_as<T>() functionSummary
Chapter 3: Casts and cv-qualifications
Technical requirementsWhat is a cast?Safety in the type system – cv-qualificationsThe C++ castsYour best friend (most of the time) – static_castA sign something’s wrong – dynamic_castPlaying tricks with safety – const_cast“Believe me, compiler” – reinterpret_castI know the bits are right – bit_castSomewhat unrelated, but still – duration_castThe reviled one – the C castSummary
Part 2: Implicit Memory Management Techniques

Chapter 4: Using Destructors
Technical requirementsOn destructors: a short recapManaging resourcesException handling… or not?The RAII idiomRAII and C++’s special member functionsSome pitfallsDestructors should not throwKnow thy destruction orderStandard resource management automation toolsunique_ptr<T> and shared_ptr<T>lock_guard and scoped_lockstream objectsvector<T> and other containersSummary
Chapter 5: Using Standard Smart Pointers
Technical requirementsThe standard smart pointersOn the exposition of intent through function signaturesType unique_ptrHandling objectsHandling arraysCustom deletersmake_uniqueTypes shared_ptr and weak_ptrUsefulness and costsmake_shared()What about weak_ptr?When to use raw pointersSummary
Chapter 6: Writing Smart Pointers
Technical requirementsOwnership semanticsWriting your own (naïve) unique_ptrType signatureSpecial member functionsPointer-like functionsWriting your own (naïve) shared_ptrA few words on make_shared()Writing a policy-based duplicating pointerDetection through interfacesDetection through traitsDetection through conceptsSome not-so-smart yet useful smart pointersA non_null_ptr typeAn observer_ptr typeSummary
Part 3: Taking Control (of Memory Management Mechanisms)
Chapter 7: Overloading Memory Allocation Operators
Why would one overload allocation functions?Brief overview of the C language allocation functionsOverview of the C++ allocation operatorsGlobal allocation operatorsNon-throwing versions of the allocation operatorsThe most important operator new: placement newMember versions of the allocation operatorsAlignment-aware versions of the allocation operatorsDestroying deleteSummary
Chapter 8: Writing a Naïve Leak Detector
Technical requirementsThe planA first implementation (that almost works)The Accountant singleton classImplementing the new and new[] operatorsImplementing the delete and delete[] operatorsVisualizing it allIdentifying (and fixing) the problemsRevisiting our implementation (and lessons learned)Summary
Chapter 9: Atypical Allocation Mechanisms
Technical requirementsPlacement new and memory-mapped hardwareSimplifying nothrow new usageOut-of-memory situations and new_handlerStandard C++ and exotic memoryA fictional shared memory APIA handmade user code exampleA standard-looking user code equivalentSummary
Chapter 10: Arena-Based Memory Management and Other Optimizations
Technical requirementsArena-based memory managementSpecific example – size-based implementationGeneralizing to SizeBasedArena<T,N>When parameters changeChunked poolsSummary
Chapter 11: Deferred Reclamation
Technical requirementsWhat do we mean by deferred reclamation?Reclamation (without finalization) at the end of the programReclamation and finalization at the end of the programReclamation and finalization at the end of the scopeSummary
Part 4: Writing Generic Containers (and a Bit More)
Chapter 12: Writing Generic Containers with Explicit Memory Management
Technical requirementsWriting your own vector<T> alternativeRepresentational choices for a container of contiguous elementsThe implementation of Vector<T>Writing your own forward_list<T> alternativeRepresentational choices for a node-based containerThe implementation of ForwardList<T>Better memory managementA more efficient Vector<T>Using low-level standard facilitiesConst or reference members and std::launder()Summary
Chapter 13: Writing Generic Containers with Implicit Memory Management
Technical requirementsWhy explicit memory management complicates our implementationImplicit memory management with a smart pointerImpact on the naïve Vector<T> implementationImpact on the sophisticated Vector<T> implementationConsequences of this redesignGeneralizing to ForwardList<T>?Attempt - making each node responsible for its successorAttempt: making the head pointer responsible for the other nodesSummary
Chapter 14: Writing Generic Containers with Allocator Support
Technical requirementsWhy allocators?Traditional allocatorsBefore C++11Traditional allocators with contemporary standardsManaging traditional allocator lifetimeIrritants with traditional allocatorsPolymorphic memory resource allocatorsNested allocatorsAllocators and data collectionUpsides and costsSummary
Chapter 15: Contemporary Issues
Technical requirementsStarting object lifetime without constructorsTrivial relocationType-aware allocation and deallocation functionsSummary
Chapter 16: Unlock Your Book’s Exclusive Benefits
How to unlock these benefits in three easy stepsStep 1
Annexure
Things You Should Knowstruct and classstd::size_tThe sizeof operatorAssertionsUndefined behaviorType traitsThe std::true_type and std::false_type traitsThe std::conditional<B,T,F> traitAlgorithmsFunctors (function objects) and lambdasFriendsThe decltype operatorPerfect forwardingThe singleton design patternInstantiation at program startupInstantiation of the first callThe std::exchange() function
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Content preview from C++ Memory Management

10 Arena-Based Memory Management and Other Optimizations

Our memory-management toolbox is growing with every chapter. We now know how to overload memory allocation operators (Chapter 7) and how to put this skill to work in ways that solve a variety of concrete problems (Chapter 8 and Chapter 9 both give a few illustrative, real-world examples).

One important reason why one would want to take control of memory allocation mechanisms is performance. Now, it would be presumptuous (and plain wrong!) to state that it’s trivial to beat the implementation of these functions as provided by your library vendor, as these are good, often very good, for the average case. The key element of the previous phrase, of course, is “for the average case.” When one’s ...

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

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C++ Memory Management

by Patrice Roy

10

Arena-Based Memory Management and Other Optimizations

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.