C++ Last-Minute Revision

30 quick revision notes for C++

1. The compile pipeline is preprocess, compile, assemble and link; a missing function body causes a linker error, not a compile error.
2. The One Definition Rule allows many declarations but exactly one definition of each non-inline function or variable in the program.
3. Signed integer overflow, out-of-bounds access and reading uninitialised variables are undefined behaviour, which optimisers assume never happens.
4. Pass small types by value, large read-only objects by const reference and use references or pointers for output parameters.
5. struct and class differ only in default access: struct is public by default and class is private by default.
6. A static local variable is initialised once and its initialisation is thread-safe since C++11.
7. constexpr allows compile-time evaluation; consteval forces it; const only prevents modification after initialisation.
8. Stack allocation is fast and automatic, while heap allocation is slower, larger and must be released by an owner.
9. RAII ties resource release to destructors, so files, locks and memory are freed even when exceptions are thrown.
10. unique_ptr is move-only sole ownership, shared_ptr is reference counted, and weak_ptr observes without owning and breaks cycles.
11. Always pair new with delete and new[] with delete[]; never mix new with free or malloc with delete.
12. A base class used polymorphically needs a virtual destructor, otherwise deleting through a base pointer is undefined behaviour.
13. Virtual calls go through a vtable pointer stored in each object, adding an indirect call and usually blocking inlining.
14. Object slicing happens when a derived object is copied into a base by value, losing derived data and behaviour.
15. Rule of zero: prefer members like vector, string and unique_ptr so you never need custom copy, move or destructor code.
16. Mark single-argument constructors explicit to prevent surprising implicit conversions such as an int silently becoming a Money object.
17. Templates must usually be defined in headers because code is generated only where they are instantiated with concrete types.
18. C++20 concepts constrain templates and produce short, readable errors compared with SFINAE and enable_if.
19. vector gives contiguous storage, O(1) random access and amortised O(1) push_back; reallocation invalidates all iterators.
20. map is an ordered tree with O(log n) operations; unordered_map is a hash table with average O(1) operations.
21. std::remove only shifts elements; combine it with erase, or use std::erase and std::erase_if from C++20.
22. std::move is only a cast to an rvalue reference; the actual move happens in the move constructor or move assignment.
23. Move constructors should be noexcept so std::vector moves instead of copies during reallocation.
24. string_view does not own data, so it must never outlive the string or buffer it refers to.
25. A joinable std::thread destroyed without join or detach calls std::terminate; std::jthread joins automatically.
26. Always wait on a condition variable with a predicate, because spurious wakeups can occur.
27. Avoid deadlock by locking mutexes in a fixed order or locking them together with std::scoped_lock.
28. False sharing occurs when threads write different variables on the same 64-byte cache line; pad hot data with alignas(64).
29. AddressSanitizer finds memory errors, UBSan finds undefined behaviour, and ThreadSanitizer finds data races.
30. Optimise by measuring first: create a benchmark, profile with perf, fix the biggest hotspot and measure again.

Night-before checklist

• Revise your saved questions on this page once, aloud.
• Read the quick notes and mark any you cannot explain in one line.
• Rehearse a two-minute self-introduction and two project stories.
• Keep CV, ID, laptop charger and interview link ready; sleep on time.