The Top 30 C++ Concepts You Need To Master for Quant Dev
Everything here is based on real interview problems reported by our members.
We sorted every C++ interview question and coding problem on getcracked by the concept it tests, then counted. These 30 concepts came out on top, ranked by how many questions and problems test each one.
For each concept you get the short version, plus the specific traps interviewers like to set. If you can explain all 30 without notes, you're ahead of most candidates.
1. Templates
A template is a blueprint the compiler stamps out at compile time, once for each set of template arguments you actually use. That's why template code usually lives in headers, and why heavy template use can bloat your binary.
What gets tested: when instantiation happens, template argument deduction, class template argument deduction (CTAD, C++17), and specialization. Class templates can be partially specialized; function templates can't, so you overload them instead.
2. Raw Pointers
A pointer holds an address. Dereferencing reads what's there, and pointer arithmetic moves in steps of sizeof(T), not bytes.
What gets tested: reading const right to left (const int* is a pointer to a const int; int* const is a const pointer), delete versus delete[], double deletes, dangling pointers, and whether delete this is ever legal (it is, carefully).
3. Object Lifetime and Construction Order
Bases are constructed before members, and members are initialized in the order they're declared, not the order of your initializer list. Destruction runs in exactly the reverse order.
What gets tested: if a constructor throws, the object never existed, so its destructor doesn't run, but the members and bases already built are destroyed. Also guaranteed copy elision (C++17), and how binding a temporary to a const& extends its lifetime.
4. Virtual Functions and Polymorphism
Virtual calls are dispatched at runtime through a vtable. Adding even one virtual function gives every object a hidden vtable pointer, usually 8 bytes on a 64-bit machine plus any padding.
What gets tested: why deleting through a base pointer needs a virtual destructor (without one it's undefined behavior), how override catches a missing const that would otherwise hide the base function, final, object slicing, and why a virtual call inside a constructor doesn't reach the derived class.
5. Smart Pointers
std::unique_ptr means sole ownership: it's move-only and, with the default deleter, the same size as a raw pointer. std::shared_ptr means shared ownership through a reference count in a separate control block, so it's two pointers wide.
What gets tested: counting allocations (std::make_shared does one, shared_ptr<T>(new T) does two), the cost of atomic reference counting when you copy, custom deleters and how they change the size, and breaking reference cycles with std::weak_ptr.
6. char, const char*, and std::string
A string literal is a const char array that includes a null terminator, so sizeof("abc") is 4. Modifying a literal is undefined behavior. std::string owns its buffer, and most implementations store short strings inline (the small string optimization), with no heap allocation.
What gets tested: == on two const char* compares addresses, not text; 'a' + 'b' is integer arithmetic; and pointers to pointers to chars.
7. std::vector
A vector is a contiguous, growable array. push_back is amortized O(1) because capacity grows geometrically: by 2x in libstdc++ and libc++, 1.5x in MSVC.
What gets tested: reallocation invalidates every iterator, pointer and reference; reserve versus resize; size versus capacity; and why elements are only moved during growth if their move constructor is noexcept (otherwis
You're one step away from reading the rest.
Sign up free to read the rest of this post. No paywall, commitment, or strings attached.