C/C++ Interview Cheatsheet

C/C++ Interview Cheatsheet#

This page is a curated, question-indexed map into the rest of the cheatsheet. Each entry below is a question you are likely to see in a C or C++ interview, followed by a link that jumps directly to the section of the notes that answers it. It is intentionally a navigation layer — the actual explanations, code, and caveats live in the linked sections.

Use it two ways:

Drilling a topic: pick a group (e.g. Templates & Generics) and walk every question in it.
Quick review before an interview: read the questions, and for any you cannot confidently answer in one or two sentences, click through.

Memory & Resource Management#

What is RAII, and why is it the cornerstone of modern C++ resource management? → cpp/cpp_raii: RAII Wrapper
How does RAII interact with exception safety (basic / strong / nothrow guarantees)? → cpp/cpp_raii: Exception Safety Guarantees
What happens when a constructor throws after partial resource acquisition? → cpp/cpp_raii: Constructor Failure and Exception Safety
Compare std::lock_guard, std::unique_lock, and std::scoped_lock. → cpp/cpp_raii: Lock-Based RAII
When does std::unique_ptr make sense vs. std::shared_ptr? → cpp/cpp_smartpointers: std::unique_ptr: Exclusive Ownership
What problem does std::weak_ptr solve? → cpp/cpp_smartpointers: std::weak_ptr: Non-Owning Observer
Why prefer std::make_unique / std::make_shared over raw new? → cpp/cpp_smartpointers: std::make_unique and std::make_shared
What are common smart-pointer pitfalls (e.g. cycles, double ownership)? → cpp/cpp_smartpointers: Common Pitfalls
Why does memory alignment matter, and how is struct padding computed? → c/c_memory: Structure Alignment and Padding

Move Semantics & Value Categories#

What are the special member functions, and when are they implicitly defined or deleted? → cpp/cpp_move: Special Member Functions
Explain the Rule of Zero, Three, and Five. → cpp/cpp_move: Rule of Zero · Three · Five
What are lvalues, rvalues, xvalues, prvalues? → cpp/cpp_move: Value Categories
How does std::forward achieve perfect forwarding, and why is it needed? → cpp/cpp_move: Perfect Forwarding
What state is a moved-from object left in, and what can you safely do with it? → cpp/cpp_move: Moved-From State
Why should move constructors typically be noexcept? → cpp/cpp_move: Conditional noexcept
emplace_back vs. push_back — when is there a real difference? → cpp/cpp_move: Emplace vs Insert

Templates & Generics#

How does template specialization differ from overloading? → cpp/cpp_template: Template Specialization
What are variadic templates and fold expressions? → cpp/cpp_template: Variadic Templates and Parameter Packs · Fold Expressions
What is SFINAE, and how do C++20 concepts replace most of it? → cpp/cpp_template: SFINAE and Type Constraints · Defining Concepts
What is CRTP and when would you use it? → cpp/cpp_template: CRTP
How does a requires clause constrain a template, and how does it compose with && / ||? → cpp/cpp_requires: Basic Requires Clause · Conjunction · Disjunction
requires vs. if constexpr — when to reach for which? → cpp/cpp_requires: Requires vs if constexpr
What are reference collapsing rules, and why do they matter for forwarding references? → cpp/cpp_basic: Reference Collapsing Rules
How does template type deduction differ between by-value, by-ref, and forwarding parameters? → cpp/cpp_basic: Template Type Deduction

Casting & Type Conversions#

Why prefer static_cast, dynamic_cast, const_cast, and reinterpret_cast over C-style casts? → cpp/cpp_casting: C-Style Cast (Legacy Casting)
When is dynamic_cast safe, and when does it return null or throw? → cpp/cpp_casting: dynamic_cast
What does const_cast actually guarantee, and when is it undefined? → cpp/cpp_casting: const_cast

Compile-Time Programming#

const vs. constexpr vs. consteval vs. constinit — pick the right one. → cpp/cpp_constexpr: constexpr Functions · consteval · constinit
How does if constexpr eliminate branches at compile time? → cpp/cpp_constexpr: constexpr if (C++17)
How has constexpr expanded across C++14, 17, 20, and 23? → cpp/cpp_constexpr: constexpr Evolution by Standard

STL Containers & Iterators#

Compare std::vector, std::deque, and std::list — memory layout, iterator invalidation, complexity. → cpp/cpp_container: std::vector · std::deque · std::list
std::map vs. std::unordered_map — trade-offs and when to use each. → cpp/cpp_container: Ordered vs Unordered Containers
What are the iterator invalidation rules for the common containers? → cpp/cpp_iterator: Iterator Invalidation
What are iterator categories, and why do algorithms care? → cpp/cpp_iterator: Iterator Categories
Walk through std::sort, std::stable_sort, std::partial_sort, and std::nth_element — when would you pick each? → cpp/cpp_algorithm: Sorting
Difference between std::find and std::binary_search? → cpp/cpp_algorithm: Searching
What are C++20 ranges and views? Are views lazy? → cpp/cpp_iterator: C++20 Ranges Overview

Strings#

std::string vs. std::string_view — when is string_view dangerous? → cpp/cpp_string: std::string_view
Why is naïve += concatenation in a loop a performance trap? → cpp/cpp_string: String Concatenation Performance

Modern C++ Features#

What does each lambda capture mode mean: [], [=], [&], [this], init captures? → cpp/cpp_lambda: Lambda Syntax Overview · Init Capture
Why is a captureless lambda convertible to a function pointer? → cpp/cpp_lambda: Captureless Lambdas and Function Pointers
What is a generic / template lambda? → cpp/cpp_lambda: Generic Lambdas (C++14) · Template Lambdas
What are C++20 coroutines, and what does co_await actually do? → cpp/cpp_coroutine: Coroutine Basics · Promise Type · Awaiter
Why would you write a generator with coroutines instead of a class? → cpp/cpp_coroutine: Generator
What are C++20 modules, and what problem do they solve? → cpp/cpp_modules: Module Basics
auto vs. decltype vs. decltype(auto)? → cpp/cpp_basic: Auto Type Deduction · decltype(auto)
What does uniform / brace initialization change about narrowing conversions? → cpp/cpp_basic: Uniform Initialization

C Language Essentials#

When does an array not decay to a pointer, and what are the signed/unsigned gotchas around pointer arithmetic? → cpp/cpp_basic: Pointer Arithmetic and Negative Indices
What does restrict promise to the compiler? → c/c_basic: Restrict Qualifier
Designated initializers and compound literals — how are they different? → c/c_basic: Designated Initializers · Compound Literals
What are flexible array members? → c/c_basic: Flexible Array Members
Why is _Generic useful, and how is it different from C++ overloading? → c/c_basic: _Generic Type Selection (C11)
What new things did C23 bring (nullptr, constexpr, typeof, attributes, bit-precise ints)? → c/c_basic: typeof and auto (C23) · nullptr · constexpr
Why are macros dangerous, and what safer alternatives exist? → c/c_macro: Variadic Macros

Concurrency & OS#

How do you create threads in modern C++? → os/os_thread: Creating Threads
Mutex, condition variable, and read-write lock — when is each appropriate? → os/os_thread: Mutex Synchronization · Condition Variables · Read-Write Locks
std::future / std::promise / std::async — what are the launch policies? → os/os_thread: C++ Futures and Async · Launch Policies
What is thread-local storage? → os/os_thread: Thread-Local Storage
Process vs. thread — what is shared and what is not? → os/os_process: Fork and Wait · Fork and Exec

Debugging & Tools#

How do you find memory leaks and invalid accesses with Valgrind? → debug/valgrind: Memcheck: Memory Errors · Leak Types
What do AddressSanitizer, ThreadSanitizer, and UBSan each catch? → debug/sanitizers: AddressSanitizer (ASan) · ThreadSanitizer · UndefinedBehaviorSanitizer
How do you inspect a core dump with gdb after a segfault? → debug/gdb: Debugging Crashes
What are breakpoints vs. watchpoints in gdb? → debug/gdb: Breakpoints · Watchpoints
Minimal modern CMake project — what are the must-have commands? → cpp/cpp_cmake: Minimal Project · Modern C++ Standard Setting