C++ Smart Pointers: From Basics to Advanced

Smart pointers are C-specific pointers that can automatically release heap memory objects and avoid memory errors. Types include: unique_ptr: exclusive ownership, pointing to a single object. shared_ptr: shared ownership, allowing multiple pointers to manage objects at the same time. weak_ptr: Weak reference, does not increase the reference count and avoid circular references. Usage: Create smart pointers using make_unique, make_shared and make_weak of the std namespace. Smart pointers automatically release object memory when the scope ends. Advanced usage: You can use custom deleters to control how objects are released. Smart pointers can effectively manage dynamic arrays and prevent memory leaks.

From basic to advanced: C smart pointers

Introduction

Smart pointers It is a special pointer in C designed to solve memory management. They effectively avoid common memory errors caused by manual memory management, such as memory leaks and dangling pointers, by automatically releasing the space pointed by the pointer to the object on the heap memory.

Types

There are multiple smart pointer types in C, each with its own unique capabilities and uses:

• unique_ptr: A smart pointer with exclusive ownership, pointing to an object that can only be managed by one pointer.
• shared_ptr: A smart pointer that shares ownership, allowing multiple pointers to manage the same object at the same time.
• weak_ptr: Weak reference smart pointer does not increase the reference count of the object and is used to avoid circular references.

Basic usage

To create a smart pointer just use the corresponding type template in the std namespace:

// 独占所有权
unique_ptr<int> p1 = make_unique<int>(42);

// 共享所有权
shared_ptr<int> p2 = make_shared<int>(10);

// 弱引用
weak_ptr<int> p3 = p2;

Release memory

A smart pointer will automatically release the object it points to when its scope ends. Therefore, there is no need to manually call delete or free.

Practical case: dynamic array management

Using smart pointers to manage dynamic arrays can avoid memory leaks caused by forgetting to manually release space:

// 普通的动态数组管理
int* arr = new int[100];

// 智能指针管理动态数组
unique_ptr<int[]> arr = make_unique<int[]>(100);

Smart pointers automatically delete the array when arr exceeds its scope. This ensures that resources are released in all cases.

Advanced usage: Custom deleter

In some cases, you may need to use a custom deleter to control how the object pointed to by the pointer is released. This can be achieved by overloading the delete operator:

class MyObject {
public:
    ~MyObject() {
        // 自定义删除逻辑
    }
};

int main() {
    unique_ptr<MyObject, decltype(&MyObject::delete)> p = make_unique<MyObject>(&MyObject::delete);
}

Conclusion

By incorporating smart pointers into the C code base, developers can significantly Improve memory management efficiency while avoiding common mistakes. This helps build more robust and reliable applications.

The above is the detailed content of C++ Smart Pointers: From Basics to Advanced. For more information, please follow other related articles on the PHP Chinese website!