Spot the Bug

Who is responsible for this pointer? Eight programs that trace the tension between allocation and deallocation.

From unique_ptr to shared_ptr to weak_ptr — ten programs that test whether you truly understand automatic lifetime.

Dangling pointers, null dereferences, and address confusion — ten programs that test your pointer intuition.

Leaks, dangling pointers, and double frees — ten programs that expose what happens when you manage memory by hand.

Dangling captures, temporary extension rules, and thread-local destruction — ten programs about when things stop existing.

Construction, copying, assignment, destruction — eight programs that follow an object from birth to death.

Slicing, hidden overloads, and suppressed moves — ten programs that reveal how C++ objects really behave.

Initialization order, brace semantics, and constructor delegation — ten programs where objects start life wrong.

Making + and = and < do the right thing is harder than it looks. Eight programs that prove it.

Virtual destructors, diamond inheritance, and CRTP typos — ten programs that push polymorphism to its limits.

Containers change shape. Nine programs that ask: is this iterator still pointing where you think?

Every STL algorithm has preconditions. Ten programs that call the algorithm correctly — almost.

Optional misuse, invalid comparators, and silent copies — ten programs where the standard library doesn't do what you assumed.

Boolean vectors, map insertion side effects, and priority queue limitations — ten programs that expose container assumptions.

Stacks, trees, heaps, and graphs — ten hand-rolled data structures with bugs lurking in the logic.

Files, buffers, connections — ten programs where something is acquired and must eventually be released.

Leaked handles, missed unlocks, and exception-unsafe constructors — ten programs that test your RAII instincts.

What does it mean to move an object? Ten programs exploring transfer of ownership and the state left behind.

Exceptions unwind the stack — but what about the promises your code already made? Ten programs on the edge of failure.

Multiple threads, one truth. Ten programs about what happens when concurrent code disagrees on reality.

Deadlocks, data races, and lock-free illusions — ten more concurrency programs that look correct until they aren't.

Memory ordering, false sharing, and lock-free pitfalls — ten programs that push beyond basic mutexes.

Type deduction, SFINAE, and instantiation surprises — ten programs that compile but don't do what you expect.

SFINAE failures, deduction traps, and double-forwarding — ten programs that test your template metaprogramming instincts.

Integer division, switch fallthrough, and operator precedence — ten beginner-level programs with traps hiding in plain sight.

Most vexing parse, operator precedence, and name hiding — ten programs that exploit the dark corners of C++ syntax.

Narrowing, truncation, and sign confusion — ten programs where the compiler helpfully destroys your data.

Integer overflow, floating-point traps, and silent truncation — ten programs where the numbers lie.

ODR violations, macro hygiene, and template linkage — ten programs that break between compile and link.

Null terminators, buffer sizes, and pointer arithmetic — seven programs from the era before std::string.

Splitting, searching, encoding — ten programs where string handling goes subtly wrong.