C++ Fundamentals: Memory, Compilation, and Containers

This is a rapid-fire C++ fundamentals interview designed to probe a candidate's deep understanding of the language and underlying machine behavior, particularly relevant for low-latency systems. The interviewer will ask about:

• The inline keyword: its guarantees, impact on call stack and binary size, and performance trade-offs.
• Dynamic allocation with new: its relationship with malloc, OS involvement, strategies to avoid the OS on the hot path, and the cost difference between heap and stack allocation.
• Templates vs. inheritance: their trade-offs for reusable and polymorphic code.
• std::map vs. std::unordered_map: their underlying data structures, worst-case scenarios, and how hash maps locate buckets.
• Segmentation faults: their cause, and specifically the scenario of attempting to dereference a null pointer via a reference.

The focus is on mechanism, cost, and practical implications rather than just textbook definitions. Discussions should include the call stack, code size, cache behavior, heap allocators, system calls, and undefined behavior.

Constraints & Assumptions:

• Modern C++ (C++17 or later).
• Ahead-of-time compilation with an optimizing compiler (e.g., GCC/Clang at -O2) for 64-bit Linux/x86-64.
• std::map refers to std::map and std::unordered_map to std::unordered_map.
• Performance discussion is for a single-threaded, latency-sensitive process; relative costs and orders of magnitude are key.
• Assume standard glibc malloc (ptmalloc2) for heap discussions, acknowledging allocator implementation variations.

Similar LeetCode problem: Inline Assembly