C++

Fundamental types

Fixed-width / size types (<cstdint>)

Deduce the type from the initializer — less noise, no implicit conversions.

Compile-time constant / function

Type alias (prefer over typedef)

const = won't change at runtime; constexpr = known at compile time.

Scoped enum — no implicit int conversion

Reference = an alias that can't be null or rebound; pointer = a nullable address.

Read-only reference — cheap, can't mutate or be null

Rvalue reference — binds to temporaries (move semantics)

Null pointer constant — use instead of NULL or 0

Manual heap management — error-prone; reach for smart pointers instead.

Tie a resource's lifetime to an object's scope — acquire in the constructor, release in the destructor.

Exclusive ownership — non-copyable, moves only, zero overhead vs raw pointer.

Shared ownership via reference counting — object freed when the last owner dies.

Construct a unique_ptr (no naked new)

Construct a shared_ptr (one allocation)

Non-owning observer; .lock() to use; breaks cycles

Borrow the raw pointer without transferring ownership

Cast to an rvalue so its resources can be stolen instead of copied — does NOT itself move.

Move constructor — steal other's resources

Move assignment operator

Perfect-forward in templates (preserve value category)

Manage all special members consistently — or, ideally, none of them.

Dynamic contiguous array — the default container for a sequence.

Ordered tree (O(log n), sorted) vs hash table (O(1) average, unordered).

Fixed-size stack array with STL interface

Owning, growable text — see the String group

Unique keys (sorted / hashed)

Group 2 / N heterogeneous values

Double-ended queue / doubly linked list

Range-based for — iterate any container without indices or iterators.

Prefer standard algorithms over hand-written loops — correct, optimized, expressive.

Iterator range [begin, end) — end is one-past-last

C++20 ranges — pass the container directly, no begin/end

Map a function over a range

Count / test elements with a predicate

Generic code instantiated per type at compile time — type-safe and zero-overhead.

Lambda — an inline anonymous function, optionally capturing local state.

Generic lambda (auto params, C++14)

Type-erased callable wrapper (has overhead)

Non-type template parameter (value, C++17)

Owning, growable string — concatenation, search, and conversion built in.

A value that may or may not be present — type-safe 'maybe' without sentinels or pointers.

Mark everything that doesn't mutate as const — the compiler then enforces it.

Non-owning read-only view of a string (no copy)

Search; npos = not found

Type-safe tagged union (C++17)

Using a reference, pointer, or iterator after the thing it points to is gone — undefined behavior.

Reading past an array or overflowing a signed int is undefined — not a guaranteed crash.

Reading a moved-from object — value is unspecified

Reading an uninitialized local is UB — always initialize

if (x = 5) assigns; compile with -Wall to catch

Copying a derived object into a base by value drops the derived parts