MEMORY WITHOUT ILLUSIONS - Modern C++ Memory Mastery from RAII to x86-64 Assembly

About this book

**Memory Without Illusions: Modern C++ Memory Mastery from RAII to x86-64 Assembly** is a practical technical guide to understanding memory across the full software stack—from high-level Modern C++ ownership abstractions to the registers, addresses, stack frames, and machine instructions that ultimately make those abstractions work.

Memory is often taught as a collection of disconnected topics: stack versus heap, pointers, smart pointers, allocators, virtual memory, caches, or assembly. This book takes a different approach. It connects these layers into a single mental model so that programmers can understand not only **how to use C++ memory facilities, but what actually happens underneath them**.

The journey begins with the fundamental memory model of a native program. Readers explore **virtual memory, Linux process maps, stack and heap organization, static storage, object lifetime, the ABI, function calls, and x86-64 registers**. These foundations provide the context required to reason correctly about addresses, storage, objects, and ownership.

The book then moves into **Modern C++ ownership and lifetime management**, emphasizing RAII and the Rule of Zero as foundations for reliable software. It examines `std::unique_ptr`, `std::shared_ptr`, `std::weak_ptr`, `std::span`, `std::string_view`, move semantics, and contracts, with particular attention to the distinction between owning and non-owning references.

Memory management is explored beyond ordinary `new` and `delete`. The book covers **aligned allocation, placement construction, explicit object lifetime, standard allocators, polymorphic memory resources (PMR), arenas, pools, and memory mapping with `mmap`**. These techniques show how applications can take greater control over allocation behavior when performance, locality, determinism, or specialized storage requirements demand it.

A defining feature of the book is its direct comparison between **Modern C++ and NASM x86-64 assembly**. Examples expose what lies beneath C++ constructs by examining function calls, stack frames, pointer arithmetic, `malloc`/`free`, memory copying, structure layout, and destructor-related behavior at a lower level. The objective is not to replace C++ with assembly, but to use assembly as a microscope for understanding what compiled native programs actually do.

The book also separates **memory-performance reality from common assumptions**. Topics such as cache locality, vector growth, small-buffer and small-string optimizations, false sharing, atomic operations, `shared_ptr` overhead, and allocation patterns demonstrate why performance cannot be understood solely by counting allocations or comparing source-level syntax.

Measurement is therefore treated as essential. Developers are encouraged to profile real programs and examine generated code before drawing conclusions about optimization.

Memory correctness receives equal attention. The diagnostic section introduces a practical toolbox including **AddressSanitizer, LeakSanitizer, MemorySanitizer, UndefinedBehaviorSanitizer, ThreadSanitizer, Valgrind, GDB, objdump, and clang-tidy**. Linux-based laboratories and engineering checklists reinforce a disciplined workflow for detecting leaks, invalid accesses, lifetime errors, undefined behavior, data races, and inefficient memory patterns.

The central philosophy of the book is simple:

**understand ownership → understand lifetime → understand storage → inspect the machine → measure reality → verify with tools.**

**Memory Without Illusions** is intended for intermediate and advanced C++ developers, systems programmers, performance engineers, library authors, and programmers moving toward low-level development. It is especially valuable for readers who want to connect Modern C++ abstractions with operating-system memory and x86-64 execution rather than treating them as unrelated subjects.

**Prepared by Ayman Alheraki**, the book provides a practical map from RAII and smart ownership all the way down to native memory and assembly—helping developers reason about memory with fewer assumptions and, as the title suggests, **without illusions**.