A safe, non-owning C++ pointer class
3 days ago
- #Pointers
- #Memory Safety
- #C++
- Safe pointers in C++ can prevent use-after-free bugs by ensuring objects outlive their references.
- Memory-unsafe languages like C++ require manual lifetime management, which can be error-prone, especially in asynchronous code.
- Rust's borrow checker offers memory safety but can be challenging to use with asynchronous code due to lifetime annotations.
- C++ compilers provide warnings and features like Clang's `lifetimebound` to catch some lifetime issues, but not all cases are covered.
- Ownership models like `std::unique_ptr` and `std::shared_ptr` can manage object lifetimes but complicate reasoning about destruction timing.
- A `safe_ptr<T>` is proposed as a non-owning pointer that updates when the pointee is moved or destructed, preventing undefined behavior.
- The `safe_ptr<T>` design uses a `std::shared_ptr<T*>` to share ownership of a pointer, ensuring safe interactions between objects.
- The pointee type must derive from `safe_ptr_factory<T>` to notify the shared state about destruction or moves.
- The `safe_ptr<T>` checks for nullptr and throws exceptions on invalid access, providing safety guarantees in single-threaded contexts.
- The implementation includes checks for validity, dereferencing, and automatic updates during moves or destruction.