Which C Pointer Type Should I Use?

When to Use Different Types of Pointers in C

In C , various pointer types are available to manage object ownership and lifetime. This article provides guidance on choosing the appropriate pointer type for different scenarios, including shared ownership, unique ownership, and non-ownership.

Shared Ownership:

• std::shared_ptr: Use when multiple objects need to share ownership of a resource, and it's unclear which object will be the last to use it.
• std::weak_ptr: Use to observe a resource without influencing its lifetime. Avoid using it to break reference cycles between shared_ptrs.

Unique Ownership:

• std::unique_ptr: The default choice for smart pointers where a single object owns a resource. It allows for customization of object deletion through a deleter template argument.
• boost::intrusive_ptr: A lightweight option when the resource already offers reference-counted management.

No Ownership:

• Raw Pointers (T*): Use for non-owning references to resources known to outlive the referencing object or for nullability and resettability.
• References: Preferred for non-null, non-owning references to resources.

Additional Notes:

• std::auto_ptr: Deprecated in C 11; replaced by std::unique_ptr.
• Boost::shared_array and boost::scoped_array: Alternatives to std::unique_ptr> const> and std::unique_ptr, respectively.
• For concurrent execution scenarios, expired() should be used cautiously to avoid race conditions when checking for resource liveness:

if(!wptr.expired()) {
  // Potential race condition
  something_assuming_the_resource_is_still_alive();
}

The above is the detailed content of Which C Pointer Type Should I Use?. For more information, please follow other related articles on the PHP Chinese website!