C++ System Design Interview Questions

Moves eliminate deep copies and reduce allocations/cache misses; copies are fine for small PODs or when value semantics simplify code. Show you profile: prefer cheap-to-move types and enable moves (=default) across boundaries.

Design contiguous layouts (compact structs/SoA) to hit cache lines and avoid pointer chasing. Use mmap/sendfile/writev to skip extra copies on hot paths, while accounting for page faults, NUMA, and security of memory-mapped regions.

Use std::pmr/arena pools when you create many short-lived small objects or churn containers; you’ll reduce fragmentation and lock contention. Keep APIs allocator-aware and validate gains with allocation/latency traces.

Fixed pools are predictable for uniform CPU tasks; work-stealing reduces idle time with mixed workloads. Expose bounded queues/backpressure, cooperative cancellation, and per-queue priorities.

Use SPSC/MPSC for predictable low-latency handoff on hot paths; prefer mutexes when contention is low or correctness is subtle. Always prove progress/ABA safety and back it with perf + correctness tests.

Choose RCU when reads dominate and can tolerate deferred reclamation; choose hazard pointers when writers are frequent or you need portability without kernel support. Decide based on read/write ratios and latency goals.

Cap connections per core, tune idle timeouts, and favor HTTP/2 or HTTP/3 to avoid HOL. Instrument queue times; shed load early with 429/503 and backoff hints.

Protobuf: compact, ubiquitous, but requires (de)serialization. FlatBuffers/Cap’n Proto: near zero-copy reads for ultra-low latency with stricter schemas. Pick based on hot-path latency, ecosystem, and tooling.

Terminate TLS at an edge proxy to keep internals plaintext over trusted links and enable sendfile/splice. If in-process, reuse buffers, enable TLS offload, and fall back to chunked writes.

Memtables + WAL, flush to SSTables, tiered/leveled compaction, bloom filters, prefix iterators, and compaction throttling. Explain trade-offs between write amp, read amp, and space amp.

Standardize on network byte order, version your messages, and avoid UB via explicit packing/static_assert(sizeof). Provide safe encode/decode helpers and fuzz parsers.

Pros: zero-copy I/O, OS page cache leverage, simple persistence. Cons: page-fault stalls, tricky error handling, NUMA surprises. Use when working sets fit and access patterns are predictable.

spdlog is fast and header-only with rich sinks; glog is stable and familiar. More important: structured fields (trace/request IDs, timings), bounded queues, and backpressure to avoid log-induced latency.

Enable core dumps, capture minimal crash context, and symbolize with debug info using addr2line/llvm-symbolizer. Bucket signatures, track regressions, and feed fixes into release gates.

Shard keys via a hash ring across cores, use per-shard locks or lock-stripes, implement TTL/size eviction (e.g., TinyLFU), and expose hit rate/eviction metrics. Provide a warmup path to avoid cold-start storms.

Use monotonic clocks, atomic counters, and per-key buckets; support bursts and distributed enforcement via periodic token sync. Offer non-blocking try_acquire() and backpressure hints.

Use lock-free rings for ingress, cache-friendly order books (contiguous price levels), deterministic sequencing, and append-only logs for durability. Pin threads, minimize context switches, and bound tail latency.

Start with locks for clarity, then justify atomics where contention hurts. Use relaxed for counters, acquire/release for publish-subscribe, and avoid seq_cst unless required. Pair reasoning with tests/TSan and microbenchmarks.