std::unique_ptr<T> is a single-owner smart pointer with zero runtime overhead compared to a raw pointer; the destructor calls delete automatically. Move-only semantics mean ownership transfers explicitly: after std::move(a), a is null and b owns the object. Use unique_ptr for almost every dynamic allocation in modern C++; the moment you reach for new, ask yourself whether make_unique would do. Pass unique_ptr by value to transfer ownership into a function, or pass the raw T* (or T&) when only borrowing for the duration of a call.

std::shared_ptr<T> keeps a thread-safe reference count alongside the object; copies increment, destruction decrements, and the object is freed when the count hits zero. Always create one with std::make_shared<T>(...) rather than shared_ptr<T>(new T(...)) because make_shared can collapse the control block and the object into a single allocation. The cost is real: refcount atomics, an extra heap allocation for the control block, and the larger pointer footprint. Reach for shared_ptr only when ownership is genuinely shared (a node referenced by multiple lookup tables, a callback that outlives its creator); otherwise stick with unique_ptr.

Two shared_ptr instances that point at each other form a cycle: the refcount of each node never drops to zero, and you have a memory leak. The fix is to break the cycle with std::weak_ptr, which observes the object without contributing to the reference count. weak_ptr::lock() returns a shared_ptr if the target is still alive, or null if it has been freed. The classic pattern is parent-child trees: parent owns children with shared_ptr, children point back at parent with weak_ptr. Apply the same pattern to caches, observer lists, and any graph where multiple nodes need to reference each other.