- Preface i
-
1 C++ Evolution and Standards 1
- 1.1 Why the Standards Story Matters 1
- 1.2 Before Standardization and the C++98/03 Baseline 2
- 1.3 C++11: The Modern Reset 2
- 1.4 C++14: Consolidation and Smoother Everyday Use 4
- 1.5 C++17: The Enterprise Adoption Sweet Spot 4
- 1.6 C++20: Another Major Expansion 5
- 1.7 C++23: Refinement, Vocabulary, and Better Defaults 7
- 1.8 C++26 and the Direction of Travel 8
- 1.9 Feature Families Every Learner Should Track 8
- 1.10 Upgrade Paths from Older Eras 9
- 1.11 Adoption Under Real Toolchain Constraints 10
- 1.12 What Upgrading Actually Buys You 12
- 1.13 How to Use the Rest of This Book 12
-
2 Language Fundamentals 14
- 2.1 Core Types and Constants 14
- 2.2 Classes and Structures 16
- 2.3 Enumerations, Casts, and Storage 19
- 2.4 Operator Overloading and User-Defined Literals 21
- 2.5 References, Initialization, and Lifetimes 22
- 2.6 Attributes and Language Features 25
- 2.7 Type System and Type Safety 28
- 2.8 Integer Semantics and ODR Hazards 30
- 2.9 Initialization and Type Deduction Pitfalls 33
-
3 Memory Management and RAII 37
- 3.1 The RAII Idiom 37
- 3.2 Smart Pointers 37
- 3.3 RAII and Ownership Foundations 43
- 3.4 Ownership Boundaries and Interface Patterns 47
- 3.5 Ownership Contracts and Handle Safety 50
-
4 Pointers, References, and Value Categories 55
- 4.1 Pointers and References 55
- 4.2 Value Categories 55
- 4.3 Borrowing and Forwarding Pitfalls 65
- 4.4 Deferred Lifetime and View Safety 68
-
5 Object-Oriented Programming in C++ 71
- 5.1 Core OOP Principles 71
- 5.2 Modern C++ OOP Safety 73
- 5.3 Composition, Dispatch, and Interface Tradeoffs 77
- 5.4 Polymorphic Lifetime and Extensibility Pitfalls 81
-
6 Templates and Generic Programming 86
- 6.1 Template Basics 86
- 6.2 Modern Template Features 89
- 6.3 Advanced Template Techniques 93
- 6.4 Practical Template Design Choices 94
- 6.5 CTAD, Constraints, and ABI Boundaries 97
-
7 STL Containers and Iterators 101
- 7.1 Sequence Containers 101
- 7.2 Associative and Unordered Containers 103
- 7.3 Iterators 105
- 7.4 Fixed-Size and Ordered Containers 106
- 7.5 Container Performance and Trade-offs 107
- 7.6 Advanced Iterator Concepts 112
- 7.7 Container Selection Beyond Big-O 115
- 7.8 Lookup and Working-Set Tradeoffs 118
- 7.9 View Invalidation and Container Benchmarks 122
- 7.10 Lifetime Hazards and Benchmark Reality 124
-
8 STL Algorithms and Functional Programming 130
- 8.1 Core STL Algorithms 130
- 8.2 Functional Programming and Lambdas 133
- 8.3 C++20 Ranges 136
- 8.4 Algorithm Pitfalls and Debugging 137
- 8.5 Algorithm and Ranges Interview Patterns 149
- 8.6 Algorithm Selection and Reviewability 153
-
9 Strings and Regular Expressions 157
- 9.1 Modern String Handling 157
- 9.2 Regular Expressions 161
- 9.3 Production String Bugs and Performance Pitfalls 168
- 9.4 String Interface and Parsing Choices 179
- 9.5 Allocation and Parsing Tradeoffs 182
- 9.6 View Lifetimes and Text Processing Realities 186
-
10 Exceptions and Error Handling 191
- 10.1 Exception Safety 191
- 10.2 Modern Alternatives 194
- 10.3 Exception and Return-Path Interview Patterns 203
- 10.4 Choosing an Error Signaling Strategy 207
- 10.5 Boundary Contracts and Failure Translation 210
-
11 Concurrency and Multithreading 215
- 11.1 Thread Management 215
- 11.2 Synchronization and Data Sharing 217
- 11.3 Higher-Level Concurrency Primitives 223
- 11.4 Asynchronous Programming 226
- 11.5 Best Practices and Common Pitfalls 227
- 11.6 Deadlocks, Publication, and Cancellation Realities 228
-
12 Metaprogramming and Advanced Templates 233
- 12.1 Type Traits and Introspection 233
- 12.2 SFINAE and Concepts 234
- 12.3 Compile-Time Computation 235
- 12.4 Advanced Metaprogramming Techniques 238
- 12.5 Template Debugging and Diagnostic Challenges 242
- 12.6 Concepts vs SFINAE: Migration Tradeoffs 246
- 12.7 Advanced Template Antipatterns 247
- 12.8 Practical Metaprogramming Contracts 255
- 12.9 Constraint Design and Compile-Time Boundaries 259
-
13 Design Patterns and Best Practices 262
- 13.1 Modern C++ Idioms 262
- 13.2 Design Best Practices 265
- 13.3 Creational Patterns 266
- 13.4 Structural Patterns 267
- 13.5 Behavioral Patterns 268
- 13.6 Modern C++ Best Practices 269
- 13.7 Pattern Overuse and Policy Boundaries 270
- 13.8 Closed Sets and Runtime Selection Tradeoffs 274
- 13.9 Pattern Boundary Failure Analysis 277
-
14 Performance Optimization and Low Level 280
- 14.1 Hardware and Memory 280
- 14.2 Compiler Optimizations 283
- 14.3 Benchmarking and Profiling 285
- 14.4 Low-Level Optimization Techniques 286
- 14.5 Profiling and Benchmarking Pitfalls 287
- 14.6 Performance Anti-Patterns and Traps 290
- 14.7 Data Layout and Benchmarking Decisions 300
- 14.8 Latency, Contention, and Tuning Priorities 304
- 14.9 Benchmark Design and Evidence Quality 307
- 14.10 Anchored Measurement and Profiling Discipline 310
-
15 Build Systems and Ecosystem 315
- 15.1 The Compilation Process 315
- 15.2 Modern Build Tools 316
- 15.3 Package Management 317
- 15.4 Visibility, CMake Scope, and Rebuild Discipline 329
- 15.5 Template Instantiation and Deployment Pitfalls 332
-
16 Testing, Debugging, and Troubleshooting 338
- 16.1 Testability and Unit Testing 338
- 16.2 Sanitizers and Failure Forensics 341
- 16.3 Flaky Tests, Debugging Workflow, and Review Questions 343
- 16.4 Framework Choice, Mocking, and Debugging Boundaries 346
- 16.5 Failure Injection and Release-Mode Reality 349
- 16.6 Reproducibility and Release-Only Failure Capture 351
- 16.7 Quarantine Policy and Investigation Handoff 353
-
17 Standard Library Utilities and Engineering Reference 356
- 17.1 Time, Clocks, and Measurement Boundaries 356
- 17.2 Filesystem and Path Semantics 358
- 17.3 Optional, Variant, Any, and Value-Wrapping Choices 359
- 17.4 Callable Wrappers, Adaptors, and Hidden Costs 362
- 17.5 Tuple, Pair, Named Types, and Boundary Clarity 364
- 17.6 Views, Diagnostics, and Utility-Layer Evidence 367
- 17.7 Utility-Boundary Cost and Lifetime Review 369
- 17.8 Time-Unit Discipline and Result-Type Clarity 371
-
18 C++ History, Migration, and Modernization Reference 374
- 18.1 Version Eras and Adoption Reality 375
- 18.2 Old vs Modern Code Comparisons 377
- 18.3 Toolchain Constraints and Conditional Adoption 379
- 18.4 Migration Failure Analysis 380
- 18.5 Version-by-Version Adoption Judgment 382
- 18.6 Feature Gating and Readability Budget 385
- 18.7 Governance, Compatibility Shims, and Migration Debt 385
- 18.8 Rollback Discipline and Mixed-Style Control 389
- 18.9 Migration Review Discipline and Sequencing 391
-
19 Reference Appendix and Decision Guides 394
- 19.1 Ownership and Lifetime Decision Guide 395
- 19.2 Error-Handling Selection Table 397
- 19.3 Container and Invalidation Quick Reference 399
- 19.4 Performance and Measurement Checklist 401
- 19.5 Concurrency and Debugging Prompts 402
- 19.6 Interview Red Flags and Green Flags 403
- 19.7 API Boundary and Deployment Quick Checks 404
- 19.8 Rollout, Observability, and Triage Quick Checks 406
- 19.9 Operational Decision Matrices 408
- 19.10 Appendix Decision Tables for Fast Triage 410
-
20 Deep STL Reference 413
- 20.1 Container Families in Practice 414
- 20.2 Iterator Categories and Algorithm Power 416
- 20.3 Adaptors, Wrappers, and Vocabulary Types 417
- 20.4 Complexity and Invalidation Quick Sheet 419
- 20.5 Algorithm Selection Tradeoffs 420
- 20.6 Modern STL and Container Review Traps 421
- 20.7 Erase/Remove Semantics and Lookup Discipline 424
- 20.8 Mutation Loops and Precomputed Comparison Work 428
-
21 C++ Strengths in Games, Graphics, and High-Performance Domains 431
- 21.1 Why C++ Still Fits Native Performance Domains 432
- 21.2 Operational Depth in Native Content and Compute Pipelines 432
- 21.3 Games, SDL, and Real-Time Loop Design 435
- 21.4 Graphics, Data Layout, and Native API Boundaries 437
- 21.5 Scientific Computing and Numerical Software 439
- 21.6 C++ Strengths Misused 440
- 21.7 Applied Domain Failure Modes and Design Choices 441
- 21.8 Operational Boundaries in Native Performance Systems 444
- 21.9 Live Editing, Benchmark Shape, and Production Confidence 446
- 21.10 Backpressure, Determinism, and Deployment Reality 448
-
22 Parallelism, Accelerators, and GPU-Aware C++ 452
- 22.1 Why This Topic Belongs in a Modern C++ Compendium 453
- 22.2 CPU Parallelism Before GPU Offload 454
- 22.3 GPU Offload and Transfer-Cost Reality 456
- 22.4 Accelerator-Friendly Data Layout and API Boundaries 457
- 22.5 Correctness Hazards in Parallel and Accelerator Code 459
- 22.6 CUDA-Style Design Judgment for C++ Engineers 460
- 22.7 Heterogeneous Execution Policy and Throughput Reality 462
- 22.8 Backend Portability and Operational Debugging 465
- 22.9 Irregular Workloads, Portability Layers, and Fleet Reality 467
- 22.10 Memory Pressure, Fallback Drift, and Fleet-Safe Offload 469
- 22.11 Capability Mismatch and Accelerator Observability 471
-
23 C++ in Distributed, Systems, Driver, and Kernel-Level Engineering 474
- 23.1 Why C++ Still Appears in Systems and Distributed Work 475
- 23.2 C++ in Distributed Systems Components 476
- 23.3 Drivers, Kernels, and Hardware-Facing Code 478
- 23.4 C++ in Operating-System and Runtime Infrastructure 480
- 23.5 When C++ Is Strong and When It Is Not 481
- 23.6 Operational Failure Modes and Systems Boundaries 482
- 23.7 Observability, Rollout, and Protocol Evolution 485
- 23.8 Partial Completion, Cancellation, and Boundary Truth 491
-
24 Embedded, Automation, and Real-Time Critical C++ 495
- 24.1 Why C++ Fits Embedded and Automation Work 496
- 24.2 Real-Time Thinking Is About Bounded Behavior 497
- 24.3 Interrupts, Context Rules, and Hidden Unbounded Work 499
- 24.4 Automation and Control-System Engineering 500
- 24.5 Embedded API and Memory-Policy Design 501
- 24.6 When C++ Is the Right Tool and When It Is Not 502
- 24.7 RTOS Reality, Priority Inversion, and Field-Failure Design 503
- 24.8 Protocol Handling, Queue Overload, and Operational Degradation 505
- 24.9 Buffer Ownership, Timeout Policy, and Field Recovery 508
- 24.10 Startup Sequencing, Calibration Drift, and Long-Field Runtime 510
- 24.11 Actuation Acknowledgement and Fault-Recovery Discipline 513
The Modern C++ and STL Interview Compendium
Interview Questions and Answers for Modern C++ Developers
A practical interview reference covering Modern C++ language features, STL usage, concurrency, and performance (525 manuscript pages).
Minimum price
$14.99
$24.99
You pay
Author earns
PDF
About
About the Book
The Modern C++ and STL Interview Compendium is a structured interview-preparation reference for developers working with modern C++ and the Standard Library.
The content is organized around the language, runtime, memory, template, concurrency, STL, build, and performance topics that experienced engineers are commonly expected to explain in technical interviews. Each section combines concise explanations with practical examples so readers can review both core concepts and real implementation tradeoffs.
The book is designed to help developers revisit important Modern C++ topics in a practical way, with a strong focus on production-oriented engineering decisions, language evolution, and maintainable system design.
Feedback
Author
About the Author
Yohan Rodriguez
Yohan is a Senior Full-Stack Software Engineer with extensive experience delivering scalable, end-to-end software solutions across web, enterprise, and cloud-based environments. He specializes in architecting robust platforms, modernizing legacy systems, driving cloud transformation efforts, and building integration-heavy applications that support critical business workflows. He is recognized for translating complex requirements into reliable, maintainable, and high-value solutions across industries such as insurance, cybersecurity, and professional services.
Known for combining strong technical execution with a practical business mindset, he has contributed to projects from concept and design through production delivery and long-term support. His experience includes collaborating with cross-functional teams, improving development workflows, solving complex technical challenges, and helping organizations deliver dependable software products that adapt to changing business needs. He brings a balanced approach to engineering that values quality, efficiency, and continuous improvement.
Contents
Table of Contents
Get the free sample chapters
Click the buttons to get the free sample in PDF or EPUB, or read the sample online here
The Leanpub 60 Day 100% Happiness Guarantee
Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
Now, this is technically risky for us, since you'll have the book or course files either way. But we're so confident in our products and services, and in our authors and readers, that we're happy to offer a full money back guarantee for everything we sell.
You can only find out how good something is by trying it, and because of our 100% money back guarantee there's literally no risk to do so!
So, there's no reason not to click the Add to Cart button, is there?
See full terms...
Earn $8 on a $10 Purchase, and $16 on a $20 Purchase
We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.
(Yes, some authors have already earned much more than that on Leanpub.)
In fact, authors have earned over $15 million writing, publishing and selling on Leanpub.
Learn more about writing on Leanpub
Free Updates. DRM Free.
If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).
Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.
Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.
Learn more about Leanpub's ebook formats and where to read them
Write and Publish on Leanpub
You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!
Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.
Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.