What are the types of C++ smart pointers and their differences?

C provides multiple smart pointer types to avoid memory errors: unique_ptr: has sole ownership of the underlying resource and automatically releases the resource when it goes out of scope. shared_ptr: has shared ownership of the underlying resource and releases the resource when the last shared_ptr is destroyed. weak_ptr: Has weak ownership of the underlying resource, does not prevent the resource from being released, but can safely check whether the resource exists. Choosing a smart pointer type depends on ownership requirements: unique_ptr for unique ownership, shared_ptr for shared ownership, and weak_ptr for handling dangling pointers.

C Types of smart pointers and their differences

In C, a smart pointer is a lightweight object. Encapsulates a raw pointer and automatically releases it when the raw pointer goes out of scope. Smart pointers help avoid errors such as memory leaks and dangling pointers.

The C standard library provides several smart pointer types, each with its own unique purpose and semantics. The following are the main types of smart pointers:

• auto_ptr: A smart pointer that automatically releases the resource it points to when it goes out of scope. auto_ptr has been deprecated in C 11 due to its ownership transfer semantics.
• unique_ptr: A smart pointer that represents unique ownership of the underlying resource. Once a unique_ptr is created, you cannot create another unique_ptr pointing to the same resource. This is the most basic smart pointer type.
• shared_ptr: A smart pointer that represents shared ownership of the underlying resource. Multiple shared_ptr can be created to point to the same resource. When the last shared_ptr is destroyed, the underlying resource is released.
• weak_ptr: A smart pointer that represents weak ownership of the underlying resource. weak_ptr does not prevent the underlying resource from being released, but it is safe to check whether the underlying resource still exists.

Practical case

Consider the following code snippet:

// unique_ptr 示例
{
    unique_ptr<string> str = make_unique<string>("Hello");
    cout << *str << endl; // 输出: Hello
} // str 超出作用域并释放 "Hello"

In this example, unique_ptr Make sure to ##str Release the string "Hello" when it goes out of scope.

Differences

The following is a summary of the main differences between the different types of smart pointers:

Featuresunique_ptrshared_ptrweak_ptr##Ownership##TransferNot supportedSupportedNot supportedScopeRelease the original pointerDo not release the original pointer (until the last reference disappears)Do not prevent the original pointer from being releasedSafetyThe safestMore secureThe least safeChoosing the right smart pointer

UNIQUE	Share	Weak

Choosing the right smart pointer type depends on the specific requirements of the application. For unique ownership scenarios, unique_ptr is preferred. For shared ownership, shared_ptr is the best choice. weak_ptr is useful for handling dangling pointers and implementing circular references.

The above is the detailed content of What are the types of C++ smart pointers and their differences?. For more information, please follow other related articles on the PHP Chinese website!