observable_unique_ptr | Unique-ownership smart pointers with observable lifetime

observable_unique_ptr is a C++ library. observable_unique_ptr has no bugs, it has no vulnerabilities, it has a Permissive License and it has low support. You can download it from GitHub.

This is a small header-only library, providing the unique-ownership smart pointers observable_unique_ptr and observable_sealed_ptr that can be observed with non-owning pointers observer_ptr. This is a mixture of std::unique_ptr and std::shared_ptr: it borrows the unique-ownership semantic of std::unique_ptr (movable, non-copiable), but allows creating observer_ptr to monitor the lifetime of the pointed object (like std::weak_ptr for std::shared_ptr). The only difference between observable_unique_ptr and observable_sealed_ptr is that the former can release ownership, while the latter cannot. Disallowing release of ownership enables allocation optimizations. Therefore, the recommendation is to use observable_sealed_ptr unless release of ownership is required. These pointers are useful for cases where the shared-ownership of std::shared_ptr is not desirable, e.g., when lifetime must be carefully controlled and not be allowed to extend, yet non-owning/weak/observer references to the object may exist after the object has been deleted. Note: Because of the unique ownership model, observer pointers cannot extend the lifetime of the pointed object, hence this library provides less safety compared to std::shared_ptr/std::weak_ptr. This is also true of std::unique_ptr, and is a fundamental limitation of unique ownership. If this is an issue, simply use std::shared_ptr/std::weak_ptr.