01 — Books Canon¶

The physical stack. Buy no more than one book per phase. Read the specific chapters the phase directory calls out; skim the rest as reference.

Prices verified from Amazon.in and publisher pages, June–July 2026. USD list → INR approximate. Ebook prices in parentheses where meaningfully lower. Delivery to Indian metros (Bangalore/Chennai/Hyderabad): 3–6 days for Amazon.in stock, 7–14 days for imported.

Phase 0–1 — Refresh & Modern C++ Core¶

1. Bjarne Stroustrup — A Tour of C++, 3rd Edition (2022)¶

Publisher / ISBN: Addison-Wesley Professional, C++ In-Depth Series. ISBN <phone_number_or_numberic_id_or_random_id_17>.
Amazon.in: https://www.amazon.in/Tour-C-Bjarne-Stroustrup/dp/0136816487 — paperback ₹3,119–₹3,230 (~$37). Kindle ~₹2,100. [LPE not available yet as of 2026.]
Publisher: https://www.informit.com/store/tour-of-c-plus-plus-<phone_number_or_numberic_id_or_random_id_18> — $44.99 paperback, $35.99 ebook.
Difficulty: I. ~240 pages. Phase: P0, P1.
Why: Fastest possible tour of the whole language from the man who designed it, updated to C++20.
Review: This is the book to read cover-to-cover in Phase 0 (2–3 weeks, ~15 hrs). Stroustrup writes without hand-holding but without cargo-cult either. Chapters 2–6 (basics, user-defined types, modularity, classes, essential operations) are the pure gold; ch. 15 (concurrency) and ch. 9 (strings/regex) are usable references. You will re-read this every 3–4 months.
Instead if short on time: read the free draft of ch. 1–4 at Stroustrup’s homepage https://www.stroustrup.com/tour3.html and skip the book. But you will want the book by month 2.

2. Bjarne Stroustrup — Programming: Principles and Practice Using C++ (PPP), 3rd Edition (2024)¶

Publisher / ISBN: Addison-Wesley. ISBN <phone_number_or_numberic_id_or_random_id_19>.
Amazon.in: search “Stroustrup PPP third edition” — paperback ₹4,200–₹4,800 (~$55) as of mid-2026. Kindle ~₹3,000.
Publisher: https://www.stroustrup.com/programming.html (author page has TOC & sample chapters).
Difficulty: B→I. ~1200 pages. Phase: P0 (reference only).
Why: The textbook Stroustrup wrote for absolute beginners — but its late chapters (I/O, GUI-lite, embedded, numerical) are useful even for a returning engineer.
Review: Do not read this cover to cover. You already know how to program. Use it as a lookup when a P0 exercise asks something like “why does this narrow-conversion warn?” Chapters 8–10 (functions, error handling), 17–18 (vectors, arrays, pointers) and 24 (numerics) are worth a targeted skim. Otherwise, Tour of C++ is your primary text.
Instead if short on time: skip entirely. Not required.

3. Scott Meyers — Effective Modern C++ (2014) ⚠️ C++14 vintage¶

Publisher / ISBN: O’Reilly. ISBN <phone_number_or_numberic_id_or_random_id_20>.
Amazon.in: https://www.amazon.in/Effective-Modern-C-Scott-Meyers/dp/<phone_number_or_numberic_id_or_random_id_20> — paperback ₹575–₹700 [LPE, Shroff Publishers]. Kindle ~₹1,900.
Publisher: O’Reilly Learning platform (see 05_paid_platforms.md).
Difficulty: I→A. ~330 pages. Phase: P1.
Why: 42 items on move semantics, rvalue refs, auto, smart pointers, lambdas, concurrency — the mental model of “modern” C++.
Review: This book is 12 years old and pre-dates C++17/20/23, so treat items on std::future, template argument deduction, and some concurrency chapters as starting points that C++20 improved. Items 1–12 (deduction, auto, enum class, nullptr), 17–22 (move & perfect forwarding), 35–42 (concurrency intro) are still the clearest exposition anywhere. Cross-reference with Josuttis (below) for post-C++14 additions. Get the LPE for ₹600, not the $50 Kindle.
Instead if short on time: read Herb Sutter’s GotW series (https://herbsutter.com/gotw/) items on move & rvalues; it is 60% of Meyers ch. 5 for free.

4. Nicolai Josuttis — C++20: The Complete Guide (2022, self-published, updated 2024)¶

Publisher: Leanpub. https://leanpub.com/cpp20.
Price: Author sets minimum $29.99 / suggested $49.99 (~₹2,500–₹4,200). PDF/EPUB/MOBI, no DRM. Free lifetime updates — Josuttis actively patches typos and adds C++23 backfill notes.
Difficulty: I→A. ~600 pages. Phase: P1, P4.
Why: The single most complete reference for what C++20 actually added (concepts, ranges, coroutines, modules, std::format, three-way <=>).
Review: Josuttis is famously thorough — you will find edge cases here that cppreference doesn’t spell out. Chapters on concepts and ranges are the ones you will reference dozens of times in Phase 1. Coroutines chapter is honest about how raw the C++20 coroutine surface is; supplement with Lewis Baker’s blog. Buy the ebook (not physical — no physical exists) so updates land automatically.
Instead if short on time: Bartek Filipek’s C++20 - Get the Details (Leanpub, ~$29) is shorter and more practical, but Josuttis is the reference.

5. Nicolai Josuttis — The C++ Standard Library, 2nd Edition (2012) ⚠️ C++11 vintage¶

Publisher / ISBN: Addison-Wesley. ISBN <phone_number_or_numberic_id_or_random_id_21>.
Amazon.in: paperback ₹1,100–₹1,400 [LPE, Pearson India]. Original US price $79.99.
Difficulty: I. ~1100 pages. Phase: P1 (STL reference).
Why: Still the most thorough STL reference in book form. C++11 vintage means it misses <ranges>, <format>, <span>, <expected> — but the containers/algorithms/iterators material is timeless.
Review: For STL chapter-and-verse questions (“what’s the complexity of std::multimap::equal_range?”, “how does std::sort interact with move-only types?”) this is the book. Skip the concurrency chapter (superseded by Williams below). Free alternative for most lookups: cppreference.com. Buy this only if you find yourself doing STL work daily.
Instead if short on time: cppreference.com + Tour of C++ ch. 11–13.

Phase 2–3 — DSA, Systems, Concurrency¶

6. Anthony Williams — C++ Concurrency in Action, 2nd Edition (2019)¶

Publisher / ISBN: Manning. ISBN <phone_number_or_numberic_id_or_random_id_22>.
Amazon.in: paperback ₹3,500–₹4,200 (~$45). Kindle ~₹2,900.
Publisher: https://www.manning.com/books/c-plus-plus-concurrency-in-action-second-edition — $59.99 print+ebook. Manning bundles print+ebook, no extra charge — buy from Manning directly if you’re OK with 3-week shipping to India, or grab the Kindle for immediate access.
Difficulty: A. ~575 pages. Phase: P3.
Why: Anthony Williams is the maintainer of just::thread and wrote large parts of <thread> for the standard. Nothing else comes close on std::atomic semantics, memory ordering, and lock-free structures.
Review: Chapters 5 (memory model) and 7 (lock-free) are the hardest and most valuable material in mainstream C++ writing. You will read chapter 5 three times over Phase 3 and still uncover new things. The 2nd edition covers C++17 additions to <execution>; there is unfortunately no 3rd edition covering std::jthread / std::stop_token in C++20 — supplement those with Rainer Grimm’s blog.
Instead if short on time: Herb Sutter’s “Atomic Weapons” talk (2 parts, ~3 hrs on YouTube — see 03_papers_and_deep_reads.md) is 70% of ch. 5.

7. Michael Kerrisk — The Linux Programming Interface (TLPI) (2010)¶

Publisher / ISBN: No Starch Press. ISBN <phone_number_or_numberic_id_or_random_id_23>.
Amazon.in: paperback ₹4,200–₹5,500 (bulky import). Ebook (No Starch) $49.95 (~₹4,200).
Publisher: https://man7.org/tlpi/ — Kerrisk maintains this page with errata & sample chapters. Author-provided free chapters cover threads, sockets, and process management.
Difficulty: A. ~1500 pages. Phase: P3.
Why: The definitive Linux syscall reference. Even 16 years later, only the io_uring / eBPF / cgroups v2 chapters are outdated; everything on epoll, threads, signals, IPC, sockets, files/mmap is textbook accurate.
Review: You will not read this cover-to-cover. Treat as the reference for anything ending in (2) in the man page section. On macOS you will develop against Darwin; when you deploy to a Linux server for Zoho or a personal cloud project, TLPI’s chapter on your subsystem is worth 4 hrs before writing code. Supplement with man pages for io_uring / cgroups v2.
Instead if short on time: Beej’s Guide to Unix IPC (free, https://beej.us/guide/bgipc/) for a 30-page taste. For sockets specifically, Beej’s Guide to Network Programming.

Phase 3–4 — Design, Performance, Tooling¶

8. Fedor Pikus — The Art of Writing Efficient Programs (2021)¶

Publisher / ISBN: Packt. ISBN <phone_number_or_numberic_id_or_random_id_24>.
Amazon.in: paperback ₹3,100–₹3,700 (~$40). Kindle ~₹2,400.
Publisher: https://www.packtpub.com/product/the-art-of-writing-efficient-programs/9781800208117 — Packt runs frequent $10 ebook sales; watch their newsletter.
Difficulty: A. ~460 pages. Phase: P3, P4.
Why: Pikus is a Mentor Graphics principal engineer who has been giving “performance is measured, not guessed” talks at CppCon for a decade. This is the distilled form.
Review: Chapters on memory access patterns, branch prediction, concurrency scaling, and compiler optimizations are exceptional. Arthur O’Dwyer’s public review calls out that the middle chapters can drag; agreed — skim the queue-benchmark chapter and land hard on the false-sharing / cache-line / NUMA material. The book will make you distrust every micro-benchmark you write, which is the point.
Instead if short on time: Pikus’s CppCon 2018 “Design for Performance” talk (free on YouTube, ~1 hr) is a compressed version of the book’s philosophy.

9. Fedor Pikus — Hands-On Design Patterns with C++, 2nd Edition (2023)¶

Publisher / ISBN: Packt. ISBN <phone_number_or_numberic_id_or_random_id_25>.
Amazon.in: paperback ₹3,300–₹3,900. Kindle ~₹2,500.
Publisher: https://www.packtpub.com/product/hands-on-design-patterns-with-c-second-edition/<phone_number_or_numberic_id_or_random_id_26>.
Difficulty: I→A. ~500 pages. Phase: P4.
Why: Patterns as C++ programmers actually use them (CRTP, policy-based design, type erasure, static polymorphism) — not the GoF Java-flavored catalog.
Review: This is the practical design book. The 2nd edition adds C++20 concepts-vs-CRTP comparisons. Chapters on type erasure and policy classes are the ones to camp on. If you have to choose one design book, this is it — unless you already know these techniques and want the philosophical treatment, in which case get Iglberger.
Instead if short on time: Klaus Iglberger “Type Erasure - A Design Analysis” talk (CppCon 2021, YouTube).

10. Klaus Iglberger — C++ Software Design (2022)¶

Publisher / ISBN: O’Reilly. ISBN <phone_number_or_numberic_id_or_random_id_27>.
Amazon.in: paperback ₹3,900–₹4,500. Kindle ~₹3,100. O’Reilly ebook via ACM sub (see 05_paid_platforms.md) is best deal.
Difficulty: A. ~430 pages. Phase: P4, P6.
Why: Design guidelines (not patterns): dependency management, ODR, physical vs logical design, why inheritance is oversold, when to use std::variant vs virtual, template-vs-concept-vs-inheritance tradeoffs.
Review: Iglberger frames every design decision as managing dependencies. Complements Pikus (Pikus is patterns catalog; Iglberger is design principles). Guidelines 15–24 (compile-time vs runtime polymorphism, type erasure, visitor) are worth 2 careful reads. Buy after Pikus.
Instead if short on time: Iglberger’s 3-part talk “Breaking Dependencies” (CppCon 2021–23) is the book in 4 hrs.

11. Marc Gregoire — Professional C++, 6th Edition (2024)¶

Publisher / ISBN: Wiley. ISBN <phone_number_or_numberic_id_or_random_id_28>.
Amazon.in: paperback ₹3,800–₹4,500 [Wiley India LPE available, ₹1,200–₹1,600]. Kindle ~₹2,700.
Difficulty: I. ~1300 pages. Phase: P1 alternative.
Why: A single-volume “here is all of modern C++ with C++23 coverage” reference. 6th edition (2024) is the freshest large book on the market.
Review: Not as tight as Stroustrup Tour, but more practical example code. If you learn best from working examples rather than terse prose, buy this instead of Tour of C++. The C++23 coverage (ranges::to, std::print, std::expected, monadic optional) is a genuine win over any 2022 book. The Wiley India LPE at ₹1,500 is one of the best value C++ books you can buy in India.
Instead if short on time: Tour of C++ 3e is 5x shorter and 80% as useful.

12. Rainer Grimm — modern C++ series¶

Grimm self-publishes on Leanpub, updates aggressively, and blogs at https://www.modernescpp.com. Key titles:

Concurrency with Modern C++ (Leanpub, ~$30) — Williams-lite; covers C++17/20/23 (jthread, latches, barriers) that Williams misses. Buy this + Williams for full concurrency coverage. [P3]
C++20 and C++23 — Leanpub, ~$25 each. Overlap with Josuttis, more digestible. [P1]
Templates – The Complete Guide — not to be confused with Vandevoorde. Practical templates. [P4]
Blog: https://www.modernescpp.com — free, updated weekly, English + German. This is the highest-signal blog in the C++ world for post-C++17 features. Bookmark.

13. Craig Scott — Professional CMake: A Practical Guide (self-published, 22nd Edition 2025, covers up to CMake 4.2)¶

Publisher: Author’s site https://crascit.com/professional-cmake. PDF/EPUB only — no physical.
Price: $30 USD (~₹2,500) for lifetime access to all future editions. Author actively releases new editions ~2×/year.
Difficulty: I→A. ~700 pages. Phase: P4.
Why: Scott is a CMake co-maintainer. This is the only book on CMake that stays current. Modern CMake (targets, generator expressions, presets, FetchContent) is nothing like the CMake you may remember from 2015.
Review: The book is dry — it is a manual, not a narrative. But when you hit target_link_libraries visibility questions or FetchContent-vs-ExternalProject dilemmas, this book has the answer with an example. Buy in Phase 4 during the build-tooling deep dive. Not before — you’ll drown.
Instead if short on time: “Modern CMake” free online book by Henry Schreiner (https://cliutils.gitlab.io/modern-cmake/) covers 70% for free.

14. Bartlomiej Filipek — C++17 in Detail, C++20 - Get the Details, C++ Initialization Story¶

Publisher: Leanpub, ~$25–$29 each (~₹2,100–₹2,500). PDF/EPUB, free updates.
Blog: https://www.cppstories.com — excellent, active, practical.
Difficulty: I. ~300–400 pages each. Phase: P1.
Why: Digestible, example-heavy walkthroughs of specific standards. Bartek writes for the working programmer, not the language lawyer.
Review: If Josuttis feels dense, buy C++20 - Get the Details instead — same coverage, more code, less spec talk. C++ Initialization Story is the single best resource on the horror show that is C++ initialization (aggregate, list-init, default, value, copy…). Worth $25 alone.

Reference tier (buy only if you use daily)¶

15. David Vandevoorde, Nicolai Josuttis, Douglas Gregor — C++ Templates: The Complete Guide, 2nd Edition (2017)¶

Amazon.in: paperback ₹3,800–₹4,500 [LPE, Pearson, ₹1,200–₹1,800]. ISBN <phone_number_or_numberic_id_or_random_id_29>.
Difficulty: E. ~830 pages. Phase: P4 (advanced templates only).
Why: The one and only comprehensive book on templates. C++17 vintage, so missing concepts/C++20 requires-expressions — pair with Josuttis C++20 for that.
Verdict: Buy the LPE and treat as reference. Reading cover-to-cover is a 2-month commitment; don’t unless template metaprogramming is your day job.

Buying strategy for India¶

First purchase (Phase 0, ~₹3,200): Stroustrup, A Tour of C++ 3e (paperback, Amazon.in).
Second (Phase 1, ~₹600): Meyers, Effective Modern C++ LPE. Do not pay Kindle price.
Third (Phase 1, ~₹2,500): Josuttis, C++20 The Complete Guide Leanpub ebook.
Fourth (Phase 3, ~₹3,500): Williams, C++ Concurrency in Action 2e paperback OR Kindle.
Fifth (Phase 4, ~₹3,100): Pikus, The Art of Writing Efficient Programs.
Sixth (Phase 4, ~₹2,500): Craig Scott, Professional CMake.

Total Phase 0–4 book budget: ~₹15,400 (~$180 over ~9 months). Everything else is optional, replaceable by talks/blogs, or reference-only.

Watch for Packt / Manning sales — Packt runs $10 ebook offers every ~6 weeks; Manning MEAP + coupon codes drop 40% off routinely. Sign up for both newsletters.

Customs / duty: Books imported to India via Amazon.in are pre-cleared — no separate duty payment. Third-party sellers on Amazon.in may ship from US; delivery 10–21 days. AbeBooks India sometimes has used copies at 30–50% off but shipping is slower.