InterviewPrepCpp

This repository is a modern C++ interview preparation toolkit, designed to deepen the understanding of core C++ concepts through clean, from-scratch implementations of data structures, concurrency primitives, smart pointers, metaprogramming techniques and more. It is organized to mirror the themes commonly explored in interviews, while encouraging a deeper grasp of language internals and performance considerations. In addition to the code, it includes a curated “References & Further Reading” section that maps out books, blogs, and documentation for going deeper into modern C++, systems programming, performance, networking, concurrency, and algorithms.

Structure Overview

include/

Header-only library code, organized by topic.

include/Containers/

Custom STL-like containers that exercise memory management, iterators, and algorithmic behavior:

• Array, Vector, String
• List, ForwardList
• HashMap (chaining) and OpenAddressingHashMap
• SPSCQueue for single-producer/single-consumer scenarios

include/Concurrency/

Basic synchronization primitives implemented manually to understand low-level threading:

• Mutex (POSIX-based)
• SpinLock (busy-wait locking)

include/SmartPointers/

Custom smart pointer implementations that mimic unique_ptr, shared_ptr, and related semantics:

• UniquePtr
• SharedPtr
• WeakPtr

include/Sorting/

A collection of classical sorting algorithms (e.g., quicksort, mergesort, heapsort) implemented with a focus on clarity and performance trade-offs.

include/Utilities/

Miscellaneous utilities showcasing advanced language features:

• Any.hpp: type-erasure container
• CompileTimeFunctions.hpp: template metaprogramming and constexpr exploration
• move_semantics.hpp: move/forward helpers and move-semantics experiments

src/

Small C++ programs that exercise and test some of the headers in include/. These files serve as usage examples and lightweight tests (for example, metafunctions_test.cpp for the metaprogramming utilities).

interview_questions/

A collection of PDF question-and-answer sets. The questions are a mix of those that were asked in real interviews (either to me personally or sourced online) and ones I created while studying specific topics. They are organized as themed sheets you can skim or drill through before an interview:

• C++ language and modern C++ features
• Operating systems and computer architecture (processes, scheduling, memory, synchronization, etc.)
• Networking (sockets, TCP/UDP, protocols, latency, etc.)

I’ll keep adding new questions and answers as I read more resources on these topics.

CMakeLists.txt

CMake build configuration for generating project files and building the code.

Purpose

This project is not meant to replace the STL. Instead, it is a learning environment to:

• Reinforce your understanding of core data structures by re-implementing them in a simple way.
• Explore concurrency and memory models at a low level.
• Practice template metaprogramming and compile-time techniques.
• Build interview-ready intuition through hands-on coding rather than rote memorization.

Build Instructions

cmake -S . -B build
cmake --build build

You can include individual headers in your own C++ test files or use the provided tests.hpp for quick experimentation.

References & Further Reading

This section collects focused resources on modern C++, systems programming, performance, networking, concurrency, and algorithms. It’s meant as a concise “reading map” for going beyond syntax into how real machines behave, how production C++ is designed and optimized, and how to reason about trade-offs that matter both in interviews and in real-world systems.

Books

C++

• Effective Modern C++ — Scott Meyers — Item-based guidelines for C++11/14 that teach how to use move semantics, smart pointers, lambdas, auto, and concurrency correctly and idiomatically.

• C++ Templates: The Complete Guide (2nd Edition) — David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor — Definitive deep dive into templates, from basic syntax to type traits and template metaprogramming, essential for understanding modern generic C++ code.

• The C++ Programming Language (3rd Edition) — Bjarne Stroustrup — Comprehensive tour of the C++ language and standard library from its creator, ideal as a foundational reference and big-picture overview.

• C++ High Performance, Second Edition: Master the art of optimizing the functioning of your C++ code — Focuses on writing cache-friendly, branch-efficient, and scalable C++ code, with practical coverage of profiling, memory behavior, concurrency, and low-level tuning.

• Beautiful C++ — Emphasizes clear, expressive, and maintainable modern C++ design, showing how to combine language features and idioms to produce elegant, robust code.

• C++ Software Design — A systems-level look at structuring C++ codebases: interfaces, boundaries, testability, and architecture patterns tailored to large C++ projects.

• C++ Memory Management — Patrice Roy’s practical guide to mastering object lifetime and memory organization in modern C++, with a strong focus on real-world constraints (real-time, embedded, games, desktop) and hands-on techniques like custom allocators/containers and allocation tuning for performance and predictability.

• The Art of Writing Efficient Programs — Fedor Pikus’s deeply practical guide to performance engineering in modern C++: how to measure first, reason about where time actually goes (CPU, memory, cache), and then apply targeted optimizations without turning your codebase into a science experiment—covering profiling workflows, data locality, algorithmic trade-offs, concurrency pitfalls, and “mechanical sympathy” techniques that reliably move real-world latency/throughput.

Computer Architecture and Operating Systems

• Computer Architecture: A Quantitative Approach (6th Edition) — Classic reference on CPU and system design, using real quantitative data to explore pipelining, caches, memory hierarchies, and parallelism.

• Computer Systems: A Programmer's Perspective (2nd Edition) — Bridges the gap between hardware, compilers, and OSes, explaining how data representation, the memory hierarchy, linking, and concurrency affect real programs.

• Operating Systems: Three Easy Pieces — Concept-driven OS textbook organized around virtualization, concurrency, and persistence, with approachable explanations and hands-on projects.

• Performance Analysis and Tuning on Modern CPUs (2nd Edition) — Practical, microarchitecture-focused guide to understanding CPU performance, covering profiling, bottleneck analysis, and low-level optimization techniques across modern processors, with an emphasis on real-world workloads and measurement-driven tuning.

Networking

• TCP/IP Illustrated, Volume 1: The Protocols (2nd Edition) — Packet-level exploration of the TCP/IP stack, illustrating how protocols like IP, TCP, and UDP really behave on the wire with detailed traces and examples.

• Computer Networks: A Systems Approach — A systems-oriented networking textbook that explains the Internet stack from links and switching up through routing, congestion control, and applications, with a strong focus on design principles, trade-offs, and real-world protocol behavior.

• UNIX Network Programming, Volume 1: The Sockets Networking API (Stevens/Fenner/Rudoff) — The definitive deep dive into socket programming: how to build robust client/server systems with TCP/UDP, handle timeouts and partial reads/writes, use nonblocking and multiplexed I/O (select/poll and related patterns), and correctly apply socket options, name resolution, and advanced topics like multicast/daemonization—exactly the kind of “no hand-waving” reference that pays off when you’re chasing correctness and latency in real networked systems.

Concurrency

• Concurrency in Action — Anthony Williams (2nd Edition) — The go-to guide for C++ concurrency primitives (threads, mutexes, atomics, futures) and patterns for writing correct, modern multithreaded C++ code.

• High Performance Parallelism Pearls Volume One: Multicore and Many-core Programming Approaches — Collection of case studies on extracting performance from multicore CPUs and accelerators, covering practical parallelization techniques and real-world workloads.

• Concurrency with Modern C++ — Modern C++11–20 treatment of concurrency and parallelism, including threads, tasks, futures, lock-free techniques, and higher-level patterns for scalable systems.

Algorithms

• Introduction to Algorithms (3rd Edition) — Comprehensive algorithms textbook (CLRS) covering data structures, graph algorithms, dynamic programming, and complexity analysis with mathematically rigorous treatments.
• Competitive Programmer's Handbook — Practical guide to competitive programming focused on problem-solving techniques, algorithm design patterns, and efficient implementations, covering topics like data structures, graph algorithms, dynamic programming, and mathematical methods with an emphasis on coding contests and real-world performance.

Linux

• The Linux Command Line: A Complete Introduction (2nd Edition) — A hands-on introduction to the Unix shell that takes you from basic commands and pipelines to shell scripting, job control, and everyday CLI workflows, giving you the practical foundation needed to be productive and confident on Linux systems.

HFT/Trading Systems

• Trading Systems Developer Interview Guide — A focused collection of real-world trading-systems interview questions and answers, with heavy emphasis on low-latency engineering, C++ performance fundamentals (memory/layout, concurrency), market microstructure basics, and the practical system-design tradeoffs you’re expected to reason about in HFT-style roles.

• High-Frequency Trading: A Practical Guide to Algorithmic Strategies and Trading Systems (2nd ed.) — A broad, pra