What C Smart Pointer Implementations Exist, and How Do They Differ?

Which C Smart Pointer Implementations Exist and How Do They Compare?

In C , a smart pointer is a wrapper class that manages the lifetime of a dynamically allocated object, providing automatic memory deallocation when it's no longer needed. Various implementations of smart pointers are available, each with its own strengths and weaknesses.

C 03 Implementations

• std::auto_ptr: A limited garbage collection facility that owns the pointed-to object but cannot be copied or used in STL containers. It's deprecated in the C standard.
• std::auto_ptr_ref: A design detail used with std::auto_ptr to allow copying and assignment in specific situations.

C 11 Implementations

• std::unique_ptr: Replaces std::auto_ptr, with key improvements for array handling, lvalue protection, and STL compatibility. It grants exclusive ownership of the pointer.
• std::shared_ptr: Wraps a reference-counted smart pointer around a dynamically allocated object, allowing shared ownership. It supports thread safety and handles incomplete types.
• std::weak_ptr: A non-owning reference to an object with a std::shared_ptr. It doesn't prevent object deletion but can retrieve the std::shared_ptr if still valid. It's used to avoid cyclic reference counts.

Boost Implementations

• boost::shared_ptr: A reference-counted smart pointer widely used due to its versatility.
• boost::weak_ptr: A non-owning reference to a boost::shared_ptr, similar to its C 11 counterpart.
• boost::scoped_ptr: A lightweight smart pointer with no copy semantics, comparable to std::unique_ptr.
• boost::intrusive_ptr: Designed for creating custom smart pointer compatible classes with customized reference counting and thread safety.
• boost::shared_array: A boost::shared_ptr for arrays, providing array manipulation features like operator[] and delete[].
• boost::scoped_array: A boost::scoped_ptr for arrays, with baked-in array functionality but is non-copyable.

Qt Implementations

• QPointer: A "weak" smart pointer for QObject and derived classes, which checks object validity before accessing but has limitations in multi-threaded environments.
• QSharedDataPointer: A "strong" smart pointer that requires reference counting implementation and is not atomic.
• QExplicitlySharedDataPointer: Similar to QSharedDataPointer, but allows control over when to detach the pointed-to object.
• QSharedPointer: An atomic reference-counted smart pointer with thread safety, custom deletes, and compatibility with boost::shared_ptr.
• QWeakPointer: A non-owning reference to a QSharedPointer, analogous to std::weak_ptr.
• QScopedPointer: Based on boost::scoped_ptr, providing a single-owner smart pointer for exception safety and compatibility.

The above is the detailed content of What C Smart Pointer Implementations Exist, and How Do They Differ?. For more information, please follow other related articles on the PHP Chinese website!