Explore smart pointers in C++

Smart pointers (Smart pointers) are a very important concept in C. Its role is to help programmers prevent memory leaks, and at the same time it also provides a more convenient and Flexible memory management. This article will conduct a detailed exploration of the concepts, types and usage of smart pointers.

1. The concept of smart pointers

Smart pointers are a modern C memory management technology that store pointers that encapsulate memory allocation and release in smart pointer objects. . Since the C language does not automatically manage memory for programmers, and programmers often forget to release memory, using smart pointers can greatly reduce the possibility of these problems.

Another advantage of smart pointers is that they can improve the maintainability of the program because they transfer memory release and object life cycle management from the programmer to the smart pointer library. In modern C, code that uses smart pointers tends to be more robust and less error-prone than code that uses raw pointers.

2. Types of smart pointers

There are three types of smart pointers in C: unique_ptr, shared_ptr and weak_ptr. They are all defined in the standard header file, and are all template classes.

(1)unique_ptr

unique_ptr is an exclusive pointer, which ensures that only one smart pointer can point to an object at any time. In other words, unique_ptr prohibits multiple pointers pointing to the same object. If you want to transfer a unique_ptr pointer to another smart pointer, you need to use the std::move() function.

The following is a sample code to demonstrate the basic use of unique_ptr:

std::unique_ptr<int> up(new int(10)); // 声明unique_ptr指针，并分配一个int类型的动态内存区域
std::cout << *up << std::endl; // 输出10
*up = 20; // 修改动态内存中的值
std::cout << *up << std::endl; // 输出20

It should be noted that when the unique_ptr pointer leaves its scope, the dynamic memory it points to will be Automatically released. (Even if there is an exception thrown)

(2) shared_ptr

shared_ptr can share the same object with multiple pointers, and you can use the use_count() function to get the number of pointers pointing to the same object. Because multiple pointers can point to the same object, care must be taken to avoid circular reference situations, which can lead to memory leaks.

Use the sample code as follows:

std::shared_ptr<int> sp1(new int(10));
std::shared_ptr<int> sp2 = sp1;
std::cout << *sp1 << std::endl; // 输出10
std::cout << *sp2 << std::endl; // 输出10
std::cout << sp1.use_count() << std::endl; // 输出2

It should be noted that every time a new shared_ptr pointer points to the same memory area, the reference count in the memory area will increase by 1. Likewise, when a pointer leaves its scope, the reference count is decremented accordingly. The memory will only be released when the reference count reaches 0. (Even if there is an exception thrown)

(3) weak_ptr

weak_ptr is a more lightweight version of shared_ptr. It cannot control the object pointed to and needs to be converted to shared_ptr before use. Because it does not affect reference counting, it does not cause memory leaks. However, it should be noted that when using weak_ptr, you need to ensure that the object pointed to exists, otherwise using the interface it provides will cause a program error.

The following is an example of using weak_ptr:

std::shared_ptr<int> sp1(new int(10));
std::weak_ptr<int> wp = sp1;
std::cout << *wp.lock() << std::endl; // 使用weak_ptr提供的lock()函数将其转化为shared_ptr，并访问内存中的值
std::cout << wp.use_count() << std::endl; // 输出1

It should be noted that when the pointed object is deleted, the shared_ptr returned by weak_ptr.lock() will be empty.

3. Use of smart pointers

Using smart pointers can greatly simplify the task of memory management because they can automatically release the dynamic memory they manage. When using a smart pointer, it needs to be initialized to a dynamic memory allocation return value. Below is some sample code to help readers better understand the use of smart pointers.

// 使用unique_ptr
std::unique_ptr<int> up(new int(10));
std::unique_ptr<float[]> u_arr( new float[5] ); // 对数组使用unique_ptr
// 使用shared_ptr
std::shared_ptr<int> sp(new int(10));
std::shared_ptr<double> sp_arr(new double[5], [](double* p){ delete[] p; }); // 对数组使用shared_ptr，并在内部传递匿名的lambda表达式释放动态内存
std::shared_ptr<Base> spb = std::make_shared<Base>(); // 使用std::make_shared创建shared_ptr指针
std::shared_ptr<Derived> spd = std::make_shared<Derived>(); 
// 使用weak_ptr
std::weak_ptr<int> wp;

if (auto sp = wp.lock()) // 使用wp.lock()检查指向的对象
{
    // 操作所指向的对象
}
else
{
    // 找不到所指向的对象
}

It should be noted that if an ordinary pointer and a smart pointer are used to point to the same dynamic memory, the smart pointer will be destructed before the ordinary pointer, which may easily cause the ordinary pointer to point to a freed (unable to memory space used).

4. Summary

Smart pointers are a very useful C memory management method. They can prevent memory leaks to a certain extent and also improve program performance. maintainability. In C++11 and later standards, smart pointers are recommended as the preferred way of memory management. In the actual development process, you need to choose which type of smart pointer to use according to the specific situation to achieve the best memory management effect.

The above is the detailed content of Explore smart pointers in C++. For more information, please follow other related articles on the PHP Chinese website!