scope-bound deterministic destruction
Imagine two ways a borrowed book gets returned. In the first, you promise to bring it back 'eventually', and a librarian may eventually come knock on your door — that's garbage collection. In the second, the moment you finish reading and stand up from the desk, the book is returned right then, every time, at a moment you can point to. C++ uses the second model, and that exact-and-predictable timing is what we call deterministic destruction.
Concretely: every object has a lifetime, and for an object with automatic storage (a local variable) that lifetime ends at the closing brace of its enclosing block, in reverse order of construction. At that precise point the destructor runs. There is no background collector, no pause, and no question of 'when'. If a function has objects a, b, c, they are destroyed c, b, a as the scope exits — and if an exception is thrown partway, the already-constructed objects are still destroyed in reverse order while the stack unwinds. This is what makes RAII reliable: 'when does cleanup happen' has a single, knowable answer.
Why it matters for systems work: when you hold a lock, a file handle, or a hardware register, you usually care a great deal about exactly when it is released — too late means contention or resource exhaustion; releasing in a nondeterministic GC pause would be a disaster for latency. Determinism is the trade: C++ gives you precise control and timing in exchange for you (or your RAII types) being responsible for correctness. The caveat: objects with dynamic storage (new without RAII), thread_local, and static objects have different, sometimes surprising destruction timing — only automatic-storage objects get the tidy at-the-brace guarantee.
void f() { Logger a; Buffer b; /* ... */ } // at the brace: ~Buffer() runs, then ~Logger() — reverse of construction order
Last constructed, first destroyed — and the timing is exact, not 'eventually'.
Deterministic does not mean instantaneous for everything you own: if a is a unique_ptr to a million-node tree, its destructor still walks and frees the whole tree at that brace, which can take real time. Predictable timing is not the same as zero cost.