C and C++

Programming with C and C++ is the broadest tour. Its C part runs from data types and format specifiers through scope and lifetime, control flow, arrays, macros, functions, strings and pointers to dynamic memory, function pointers, structures, bit fields and unions, with an appendix on GCC options, Valgrind, command-line arguments and file I/O.[3] Its section on loops is typical of its manner: an infinite while(1) loop comes with the warning that it burns CPU unless the operating system supplies a way to wait for events, and goto is shown with a legitimate use, unwinding a failed initialisation, beside the note that automotive and aerospace software treats it as bad practice; out-of-bounds access to an array is introduced as a major security problem.[3]

101 C, C++ and Linux Systems Programming Problems takes the question-and-answer route: what does a printf with more format specifiers than arguments print, and why does passing a null pointer to a %s specifier crash the program; the answers, with a variadic logging function built on va_list and vfprintf and a worked allocation of structures with calloc, are a page each.[2] The author describes it as a free, still-developing set of notes, and the C++ and Linux sections are a few pages apiece.[2] C From Scratch is the opposite in temperament: eleven chapters on fixed-width integers, booleans, arrays, strings, structures, pointers, functions as contracts and state machines, with appendices on contracts and undefined behaviour, and a method from aerospace and medical-device certification that defines correctness and data invariants before any code is written.[4] Welcome to C teaches C by contrast with Java for students switching languages for a systems course.[5]

Three books teach C by building one program. Build Your Own Lisp is the oldest, from 2015, and its project is an interpreter for a small Lisp, about a thousand lines, written step by step for readers who want to learn C or are curious how a language is built.[6] Build Your Own Redis with C/C++ writes a Redis-like key-value server from scratch in fifteen short chapters: sockets, a TCP server and client and a request-response protocol first, then an event loop, hashtables, serialisation, a balanced tree for sorted sets, timers with TTL expiry and a thread pool, each introduced where the server needs it.[8] Programming Linux Anti-Reversing Techniques starts from a plain C bind shell, built with CMake, and modifies it chapter by chapter to show how a reverse engineer would analyse the binary and how to frustrate the analysis, from compiler flags and stripped symbols through the ELF layout, LD_PRELOAD and static linking against musl to ptrace-based anti-debugging; it dates from 2016 and C is its vehicle rather than its lesson.[9] For C programmers using a library rather than writing one, NNG Reference Manual collects the manual pages of NNG, a broker-less messaging library, into a function-by-function reference whose free sample, the about text says, is the whole book.[10]

The sources treat C++11 as the base the later standards build on, and three of them take one C++11 feature each as a whole book. C++ Move Semantics - The Complete Guide is about move semantics, from rvalue references and std::move through the moved-from state, noexcept, value categories and perfect forwarding to move support in the standard library, with chapters on auto&& and decltype(auto) that a general C++ book would not spare the space for.[19] Notebook C++: About Move Semantics covers the same ground as 24 numbered notes, each labelled with the first standard where it applies, and its stance is cautionary: most of the time a program should stay away from std::move, and return values and temporaries should not be moved.[20] C++ Lambda Story tells the story of lambda expressions from the functor era through C++11, C++14's generic lambdas, C++17's constexpr lambdas and handling of the this pointer, and C++20, revisiting each technique as later standards extend it;[21] the author suggests that beginners skip the history and start at the C++11 chapter.[21]

C++ Initialization Story takes initialisation as its lens, on the grounds that there are more than a dozen ways to initialise a simple integer and complex rules for auto, data members and object lifetime behind them.[22] Its first chapters lay out the forms, aggregate, constant, default, direct, copy and list initialisation, and the book goes on to constructors and the copy and move operations, C++11's non-static data member initialisation, C++17's inline variables and C++20's designated initialisers, with two quizzes, an appendix on the rules for compiler-generated special member functions, and a Compiler Explorer link on every example.[22]

C++17 in Detail opens with structured bindings as the kind of feature that makes code more compact: where C++11 needed std::tie and two declared variables to take the pair returned by a set's insert, C++17 writes one line with named bindings, and the book goes through the modifiers, the three cases a binding can decompose, an array, a tuple-like type and a plain struct, and the limitations, among them that a binding could not be constexpr or captured by a lambda until a C++20 fix.[12] Its three parts cover the language changes, the new library types, std::optional, std::variant, std::any and std::string_view, the filesystem and the parallel STL, and longer examples that combine them, such as replacing enable_if with if constexpr and parallelising a CSV reader, with each feature's implementation status in GCC, Clang and MSVC as of 2019.[12] C++17 - The Complete Guide covers every C++17 feature, including the expert utilities, polymorphic memory resources, std::launder and over-aligned new, with afternotes on each feature's history.[13] The concurrency book places C++17's contribution precisely: most standard algorithms became available with an execution policy, sequential, parallel or parallel and vectorised.[36]

C++20's overview chapter is the quickest map of the standard. Concepts let a template state its requirements as part of its interface, so that a greatest-common-divisor function can be declared with an Integral concept in place of auto and the compiler checks the arguments at the call rather than deep inside the instantiation; a module is declared with an export line and imported by name, promising faster compiles and an end to header files; the ranges library lets algorithms work on containers directly, lazily and composed with a pipe; and coroutines arrive as a framework of more than twenty customisation points rather than ready-made types, which the book illustrates with a generator built on co_yield.[16] The smaller changes get a paragraph each, among them a defaulted three-way comparison operator that generates all six comparisons, consteval and constinit, std::span as a non-owning view that remembers its size, safe comparison of signed and unsigned integers, std::format with Python's syntax, and calendars and time zones in chrono.[16] C++20 - The Complete Guide gives each of the large features several chapters, with full catalogues of the standard concepts and view types and a chapter on coroutine internals.[14]

Programming with C++20 teaches by longer worked examples: a byte-stream parser with coroutines, a range adaptor with pipe syntax, a format function checked at compile time.[17] Its sample chapter on the three-way comparison starts from a medical-record-number class, shows how much code equality and ordering needed before C++20, with the friend trick and overloads in both directions, and how operator rewriting and a defaulted spaceship operator remove it, with a pitfall when the operator is defaulted over members written before C++20.[17] C++ Concepts is devoted to one feature and explains why it exists: overloads for every numeric type are tedious, an unconstrained template hides its requirements in its body and fails with long error messages at instantiation, deleting specialisations one at a time does not scale, and a static assertion over type traits is verbose; a concept states the requirement in the function header, at no runtime cost.[18] Its car-and-tank example separates syntactic requirements, which the compiler checks, from semantic ones, which it cannot: a Tank class with every method of the car concept satisfies it without being a car.[18] On the concurrency side C++20 added std::jthread, which joins in its destructor and can be interrupted cooperatively through stop tokens, along with semaphores, latches and barriers.[36]

The C++ Standard Library is written against C++23 and notes that where a compiler supports the modularised standard library, the headers in its examples can be replaced with a single import of std.[11] C++23 - The Complete Guide covers the standard feature by feature, modules, std::print and formatted output, deducing this, std::expected and its monadic operations, std::stacktrace, std::generator, std::mdspan, span streams and the flat containers, and is published incrementally with free updates as chapters are added.[15] C++23 Best Practices revises its author's earlier guidelines for C++23, with the candid note, as of 2024, that no compiler could yet compile all of its examples as written.[34] The C++ Interview Book, a 2026 second edition of an interview book, tags questions by seniority and already asks about C++23's deducing this and std::expected and C++26's contracts, reflection and pack indexing.[58]

How to use const in C++ spends its first chapter on the objections a developer will hear when making more things const: that it is visual noise, that it confuses people, that it does not matter. The author answers each: unlike a comment that repeats the code or a type that auto could deduce, const adds information that cannot be expressed more simply; the confusion comes from its absence in an inconsistent codebase; and as for performance, he retells a CppCon 2016 talk in which adding const to a static array of sixteen colours cut the compiler's output from about 350 instructions to about 5.[23] The remaining chapters take const in each context, local and member variables, functions and their overloads, return types, parameters, smart pointers and rvalue references, and leave constexpr, consteval and constinit aside.[23]

Six puzzle books drill lifetime and copying without explanation. In the three Object Lifetime Puzzlers, Object Lifetime Puzzlers Book 1, Object Lifetime Puzzlers Book 2 and Object Lifetime Puzzlers Book 3, every object prints one name when its lifetime begins and another when it ends, and the reader works out the order of construction and destruction of static, local and scoped objects to spell a C++ term, 128 puzzles a volume with difficulty rising at a leisurely pace.[24][25][26] The three Copy and Reference Puzzlers, Copy and Reference Puzzlers Book 1, Copy and Reference Puzzlers Book 2 and Copy and Reference Puzzlers Book 3, pose short functions full of copies, references and reassignments and ask what the final print shows; the second volume adds std::swap and the third std::exchange.[27][28][29]

C++ AUTOPSY presents ten bugs that compiled, ran and lied, as forensic cases. Its free case is a function that builds a label in a local std::string and returns a std::string_view into it: the program compiles without a diagnostic under -Wall and -Wextra and even under the static analyser, prints blanks or garbage or crashes, and only AddressSanitizer names the fault, a read of exactly fifteen bytes from a stack frame that no longer exists.[30] The lesson generalises to std::span, iterators, references and raw pointers: a non-owning handle must never outlive its owner, a function that builds its result should return the owning type, and a view must never be bound to a temporary; the about text says the book was produced with AI assistance and human review.[30]

Notebook C++: Tips and Tricks with Templates is a pocket reference of 24 notes on writing templates, from the first note's insistence on the term function template rather than template function through type and non-type parameters, variadic templates, decltype and declval, void_t, fold expressions and where to put enable_if, each note labelled with the earliest standard it needs and many looking behind the scenes with the author's C++ Insights tool.[31] C++ Lambda Story supplies the techniques that lambdas made idiomatic, immediately invoked function expressions, the overloaded pattern, generic and recursive lambdas, storing lambdas in containers and passing them to threads and std::async, with an appendix listing them.[21] Design Patterns in Modern C++ opens with three C++ idioms a pattern book needs: the curiously recurring template pattern, in which a class passes itself as a template argument to its base so that the base can cast this to the derived type; mixin inheritance, in which a class inherits from its own template argument so that nested instantiations compose; and static polymorphism built on the first.[32]

The C++ Standard Library is the one compact reference: about 350 pages and more than 150 runnable examples across utilities, containers, iterators, algorithms, ranges, strings, streams, formatting, the filesystem, multithreading and coroutines, deliberately shallow per topic and linking to cppreference at the start of each one for the details it leaves out.[11] It draws a distinction it keeps throughout, calling instances of the fundamental types inherited from C values and instances of user-defined types and containers objects.[11] The library's growth is visible across the other sources: C++17's optional, variant, any and string_view are what one book calls a new vocabulary for C++ code,[12] C++20 made vector and string usable at compile time and gave the associative containers a contains member,[16] and the C++ part of Programming with C and C++ walks a beginner through the containers, the smart pointers, and threads, mutexes and condition variables.[3]

C++ Best Practices is about fifty rules, each a few paragraphs with exercises to apply to the reader's own code, drawn from the author's twenty years as a developer and trainer and marked where a rule needs C++20.[33] Its successor, C++23 Best Practices, reorganises the rules into sixty-seven sections in five parts: philosophy, tooling (tests, warnings, sanitisers, fuzzing, package managers), API and code design, and implementation guidelines.[34] No More Helloworlds. Build a Real C++ App argues the same practices through one application rather than a list, and is described below with the build tools.

Design Patterns in Modern C++ reworks the Gang of Four patterns in C++11 through C++17. Its introduction recalls that the original patterns book had its examples in C++ and Smalltalk, that languages such as C# have since built patterns like Observer into their syntax, and that C++ has not, though std::function made much simpler; it then recaps the SOLID principles with a journal class whose persistence is moved into a separate class to give each one reason to change.[32] The examples deliberately omit const and virtual destructors to fit the page, which the author flags.[32] Implementing QuantLib is a design report on a real C++ library, and patterns appear in it where the code grew into them. A financial instrument is an abstract base with three methods, its value, an error estimate and whether it has expired; pricing is a Strategy; instruments observe their market data through the Observer pattern and a Handle, a shared pointer to a pointer that lets every copy follow a switch of data source; and a LazyObject base caches results with the Template Method pattern, with a flag set before the calculation so that a recursive call cannot loop and reset in a catch block so that an exception does not leave stale results marked valid.[35] An aside on why the cached value is mutable ends with the note that C++11 requires const methods to be thread-safe, which the design does not yet address; the book assumes both C++ and quantitative finance and teaches neither.[35]

Concurrency with Modern C++ is the reference, at some 124,000 words. Its first chapter lays out the ground: reading and writing a shared variable concurrently is a data race and therefore undefined behaviour; C++ has five kinds of mutex and a lock encapsulates one so that RAII releases it; read-only shared data needs only thread-safe initialisation; and condition variables are hard enough to use correctly that tasks, promises and futures are often the easier answer.[36] The case studies sum a vector several ways with drastically different timings, solve the dining philosophers, and weaken the memory ordering of a small program step by step while verifying each step with the CppMem tool; later chapters catalogue concurrent architectures, Active Object, Monitor Object, Half-Sync/Half-Async, Reactor and Proactor, and lock-based and lock-free data structures.[36]

Ace the Trading Systems Developer Interview (C++ Edition) shows where that knowledge is examined. Its twenty sample questions, from a book of more than 120 for trading-systems roles at hedge funds, banks and exchanges, ask what the CRTP is, which of two && parameters is a forwarding reference, how to implement a read-write lock that favours waiting writers and a bounded single-producer single-consumer lock-free queue, what the memory orders relaxed, acquire, release and sequentially consistent mean, and why a thread reading one char of a two-char struct slows down when another thread writes the other: false sharing.[37] The domain questions, a fast limit order book, a streaming median in a megabyte of memory, FIX versus binary protocols, sit beside chapters on the industry, its roles and its pay.[37]

Build a SQL Database Engine in C++ builds a single-threaded SQL engine in C++20 over fourteen units: slotted pages and a pager, a B+Tree and a buffer pool; a record layer, a catalog, a parser and an executor that reaches end-to-end SELECT and INSERT; joins, aggregation, indexes, a planner and vectorised execution; and a write-ahead log with crash recovery and a capstone checked against PostgreSQL and benchmarked against SQLite.[38] Its method is stated as a contract: nothing is asserted, everything is demonstrated, every performance claim is a table printed by a benchmark whose source is on the page, and every unit reproduces one real bug and locks it shut with a regression test.[38] The conventions are a storage engine's: expected outcomes travel in std::optional and bool and never throw, broken invariants halt the process, and every on-disk byte is explicit, little-endian and written with memcpy rather than a struct overlay, with the build refusing a big-endian host rather than claiming untested portability.[38] Concurrency and MVCC, a wire protocol and the full SQL grammar are out of scope, and the about text says the book was produced with AI assistance and human review.[38]

Build an LLM Inference Engine in C++, by the same author, applies the method to a CPU-first inference engine in C++20 that by its fourteenth unit loads a Llama-family model in GGUF format and generates text, passing through arena allocation, SIMD kernels and GEMM, a BPE tokeniser, the KV cache and flash attention, quantisation and speculative decoding, with an optional CUDA capstone.[39] Beneath CUDA C++, Mastering PTX and SASS explains how it compiles first to PTX and then to architecture-specific SASS, and how reading both diagnoses register pressure, occupancy and divergence; it is NVIDIA-specific and for programmers who already know CUDA.[40] Build Your Own Redis with C/C++, described with the C books above, belongs to the same family.

Mastering STM32 - Second Edition is a roughly 900-page guide to programming STM32 microcontrollers with STM32CubeIDE, CubeMX and the CubeHAL, using nine Nucleo boards, in three parts: setting up the toolchain, the basics of STM32 programming and the HAL, and advanced matters such as a real-time operating system, the boot sequence and USB.[41] Its twenty-eight chapters go peripheral by peripheral, GPIO, interrupts, UART, DMA, the clock tree, timers, ADC, I²C and SPI, and then to the parts a C programmer rarely sees: a linker script designed from scratch, a custom bootloader that upgrades firmware over USART with AES encryption, FreeRTOS through the CMSIS-RTOS v2 layer, the USB device stack and the design of a custom PCB.[41] The author is explicit that the book is a guide to the official HAL, not a replacement for datasheets that run to thousands of pages; asked whether to learn Arduino or STM32, he answers that Arduino is fine for professional work but hides too much of what is under the hood, and that the low-cost STM32F0 line is known as the 32-bit MCU for 32 cents.[41] Two shorter books sit on the same chips. Runtime Patterns for Embedded Systems presents eight run-time patterns for firmware, from a single task through nested state machines, event lists, message pumps, cooperative fibres and event queues, each with source from an MIT-licensed demo that runs on an STM32F746G Discovery board with a touchscreen.[42] FreeRTOS on the STM32F7 microcontroller is a 176-page book on FreeRTOS on the STM32F7 whose public listing gives only two chapter titles, the startup sequence and interrupts.[43]

Knowing the RP2040 explains the chip at the heart of the Raspberry Pi Pico rather than restating its datasheet, which the author says tells what things are but not why they matter or how to use them.[44] Its architecture chapter walks the block diagram: two Cortex-M0+ cores at 133 MHz with a single-cycle I/O block for synchronising them; 264 KB of RAM in six blocks so that both cores run without contention; a 16 KB boot ROM that presents the board as a USB mass-storage device for programming; external flash executed in place through a cache; and two programmable I/O blocks of four state machines each, which implement protocols that other microcontrollers have to bit-bang.[44] The examples are in C on Pico SDK 1.5.0, and the author concedes that the SDK's manual installation and its use of CMake are a hurdle for readers used to an IDE.[44]

The two Kolban books are collated notes rather than tutorials. Kolban's book on ESP32 gathers what the author learned programming the ESP32 from the Espressif SDK documentation and the community forums, re-released as material was added, for readers who want more background and examples than the official PDFs give;[45] Kolban's Book on the ESP32 & ESP8266 is the earlier volume and, despite its title, is about the ESP8266, referring ESP32 readers to the other book.[46] Both date from 2016 to 2018 and have no table of contents in their listings.[45][46]

Two 2026 books bring modern C++ to firmware. C++ for Embedded Systems is a 548-page guide to writing microcontroller firmware in C++: fixed-width types, const and volatile, the limits of the STL on a small device, the peripherals and interrupts, integration with FreeRTOS and Zephyr, low-power design, bootloaders and over-the-air updates, with a code sample and exercises in every subsection.[47] Designing Deterministic Systems with Modern C++ builds an embedded-style system, a weather reporter device, in C++17 on an ordinary Linux host before any hardware exists, treating the host, with CPU isolation, memory locking and scheduling policies, as the primary environment for development and validation, and covering bounded execution, explicit ownership, type erasure, NMEA serialisation and deterministic sensor pipelines.[48]

Two books stand beside the C in embedded work without containing any. Wired Protocols in Embedded Systems starts from the electrical principles a protocol rests on, TTL and CMOS logic levels, pull-up and pull-down resistors, output stages and the wired-AND connection, and takes 1-Wire first because, simple as a single data line looks, it uses the arbitration and addressing that I²C and I3C build on; UART, SPI, I²C and I3C follow in detail, with shorter coverage of RS-485, CAN, USB and Ethernet.[49] Its classification of protocols by duplex mode, synchronisation and serial or parallel transmission is illustrated with a cargo-tracker board on which a temperature sensor speaks 1-Wire, a GPS module UART and a flash chip SPI.[49] Diving into JTAG goes down to the JTAG protocol itself, the TAP state machine and its registers, debugging an STM32F407 through it, boundary scan for board testing, and then to attacks, dumping firmware from a Cortex-M0 and bypassing the nRF52's access protection; the author notes that the same material is free in his blog posts.[50]

No More Helloworlds. Build a Real C++ App follows one complete C++ application to show how the pieces fit, and its contents are a map of the territory: an architecture chapter on UML, layered and hexagonal architecture, error handling by exceptions and by error codes, and Docker-based development environments; a CMake chapter on targets, property propagation and when to use PUBLIC and PRIVATE, interface and external libraries, build types, and the CMake language itself; a chapter on the core logic with interfaces, virtual destructors, smart pointers, dependency injection and the split between public and private API at the build-system level; and testing with GTest.[51] Its first edition is dated July 2026 and the sample is front matter and contents only.[51] CMake recurs elsewhere: it builds the bind shell in Programming Linux Anti-Reversing Techniques[9] and is the official way to build for the Pico SDK, with an appendix in Knowing the RP2040.[44]

The standards books are practical about compilers. C++17 in Detail gives the flags for C++17 on GCC, Clang and Visual Studio 2017 and points to the online compilers its examples were written on, Coliru, Wandbox and Compiler Explorer, along with C++ Insights, which shows how the compiler sees a lambda or a structured binding by expanding it.[12] Notebook C++: Tips and Tricks with Templates names the exact g++ and clang releases its code was tested with,[31] and C++ Initialization Story notes that a term selected in Compiler Explorer can be looked up on cppreference from the context menu.[22]

The undefined-behaviour case in C++ AUTOPSY is also a demonstration of the tools' limits: warnings and the static analyser miss a dangling pointer hidden inside a view, because proving that a pointer escapes its object's lifetime across function boundaries is undecidable, and the book's advice is to run the tests under AddressSanitizer.[30] C++23 Best Practices puts tests, warnings, sanitisers, fuzzing and package managers together in its tooling part,[34] and C From Scratch closes with a chapter on the path to production that includes static analysis.[4] Building Computer Security is a general security guide for engineers who are not specialists, written to be read twice and following an 80/20 rule of many short tips over polish; its programming and testing chapters are the C-relevant part: defensive programming, asserts combined with fuzzing, the compiler's hardening features, Clang's static and dynamic testing, Flawfinder as a zero-effort check and Cppcheck as a stronger one that needs configuration.[52] It has chapters on IoT devices and the CAN bus as well, and its author says breadth was prioritised over depth.[52]

Several books by one author teach what the compiler produced rather than what the programmer wrote. Practical Foundations of Windows Debugging, Disassembling, Reversing, Second Edition is the foundation course, which disassembles small C and C++ programs to teach memory and registers, debug versus release builds, pointers, the stack and frame pointer, and how function parameters are passed, in a set of chapters for x86 and a parallel set for x64.[53] Accelerated Windows Memory Dump Analysis, Seventh Edition, Part 1, Process User Space is the first part of a crash-dump course, 26 exercises on x64 and ARM64 process dumps covering stack traces, modules, heap corruption, leaks, deadlocks and CPU spikes, each revealing one of the author's named analysis patterns.[54] Frida handbook approaches native code from the other side, instrumenting running programs with Frida; its scripting is JavaScript, and C enters through CModule, custom shared libraries and parsing structs.[55] On the embedded side, Mastering STM32 - Second Edition has a chapter on reading the Cortex-M fault registers back to the source of a fault, the watchpoints, expressions and SWV tools of STM32CubeIDE, and SEGGER J-Link debuggers,[41] and Programming with C and C++ introduces Valgrind in its appendix.[3]