方寸之间

Introduction#

C++ is a widely used programming language that allows programmers to use dynamically allocated memory. However, manual memory management can lead to serious issues such as memory leaks and dangling pointers. To address these problems, C++ introduced the concept of smart pointers. Smart pointers are a special type of pointer that can automatically manage memory and ensure that it is released when no longer needed. The use of smart pointers in C++ programs has become increasingly common, such as smart pointers used in STL containers and COM interface programming.

This article will introduce the concept, types, and implementation principles of smart pointers to help readers better understand and apply smart pointers.

Basic Concepts#

A smart pointer is a C++-specific pointer that encapsulates a regular pointer and provides automatic memory management. It automatically releases the memory it occupies when the object is no longer in use, avoiding the errors and troubles associated with manual memory management. The design idea of smart pointers is an application of the Resource Acquisition Is Initialization (RAII) technique, which binds the lifetime of an object to the lifetime of a smart pointer, enabling automatic management of the object.

Compared to regular pointers, smart pointers have the following characteristics:

1. Automatic memory management without the need for manual memory deallocation.
2. Ability to track the reference count of a pointer and automatically manage the object's lifetime.
3. Ability to simulate the effect of object copying and ensure that the same block of memory is not released twice during destruction.
4. Ability to implement custom resource management through the use of deleters.

However, smart pointers also have some disadvantages:

1. Additional overhead: Smart pointers require additional overhead in their implementation to manage the lifetime of the pointer, which may lead to performance issues.
2. Circular reference problem: When using shared_ptr, if there is a circular reference, i.e., two or more objects hold shared_ptr pointers to each other, it may lead to memory leaks.
3. Inability to handle non-heap memory objects: Smart pointers are only suitable for heap memory objects and cannot manage stack memory or global variables.
4. Lack of support for arrays: Smart pointers can only manage individual objects and cannot manage arrays. If array management is required, specialized array smart pointers should be used.

The lifetime of a smart pointer is determined by its scope and reference count. When a smart pointer object goes out of scope, it automatically releases the memory it points to, thus avoiding memory leaks. When multiple smart pointers point to the same object, their reference count increases, and the object is only released when the reference count reaches 0. In other words, the scope and lifetime of smart pointers are automatically managed, effectively avoiding the occurrence of memory leaks and other memory management issues.

Types of Smart Pointers#

The common types of smart pointers in C++ are unique_ptr, shared_ptr, and weak_ptr.

1. unique_ptr
   unique_ptr is an exclusive smart pointer that manages resources in an exclusive ownership manner. This means that each resource can only be owned by one unique_ptr, and once the unique_ptr is destroyed, the resource it owns will also be released. unique_ptr is a feature introduced in the C++11 standard, providing a more efficient and safer way of resource management.

2. shared_ptr
   shared_ptr is a shared smart pointer that allows multiple shared_ptr objects to share the same resource, which will be released only after all the shared_ptr objects that reference it are destroyed. shared_ptr tracks the usage of the resource through reference counting. Once the reference count reaches 0, the resource is released. Unlike unique_ptr, shared_ptr can transfer ownership and can be constructed from a raw pointer or another shared_ptr object.

3. weak_ptr
   weak_ptr is a weak reference smart pointer, which is an extension of shared_ptr but does not perform reference counting on the resource. It can only be constructed from a shared_ptr object and cannot directly manipulate the managed resource. In general, we use weak_ptr to solve the circular reference problem of shared_ptr.

Tips for Usage#

• Use unique_ptr whenever possible: Use unique_ptr whenever exclusive ownership is not required. It ensures unique ownership of the pointer, avoids memory leaks, and has good performance.

• Use shared_ptr to manage shared resources: Use shared_ptr when multiple objects need to share the same resource. shared_ptr uses reference counting to ensure that the resource is only released when the last owner is destroyed.

• Use make_shared or make_unique to create smart pointers: When creating smart pointers, it is recommended to use the make_shared or make_unique functions instead of directly using the new operator. This reduces memory allocation overhead and avoids memory leaks.

• Avoid using smart pointer arrays: Smart pointers do not support managing dynamic arrays. Therefore, when managing arrays, it is recommended to use container classes from the standard library, such as vector.

• Avoid using raw pointers: Avoid using raw pointers as much as possible, as they are prone to misuse. Especially when using smart pointers, it is recommended to avoid mixing raw pointers and smart pointers.

• Avoid converting smart pointers to raw pointers: When using smart pointers, it is recommended to avoid converting them to raw pointers. If conversion is necessary, use the get function to obtain the raw pointer instead of directly using the address of the smart pointer.

• Use const references when passing smart pointers to functions: When passing smart pointers as parameters to functions, it is recommended to use const references to avoid unnecessary copying and memory allocation.

Considerations#

1. Be aware of the circular reference problem: shared_ptr is a type of smart pointer that allows multiple pointers to share the same object. However, if there is a circular reference, it can lead to memory leaks.
   Circular reference refers to the situation where two or more objects refer to each other, causing their reference count to never reach zero, resulting in memory leaks. To avoid circular references, the following methods can be used:

• Use weak_ptr to break the circular reference.
• Try to avoid circular references.
• Use container classes provided by the standard library, such as std::list or std::vector, instead of manually managing memory.

2. Be aware of thread safety issues: When using smart pointers in a multi-threaded environment, it is important to consider thread safety. If multiple threads access the same smart pointer simultaneously, it can lead to race conditions. To avoid this problem, the following methods can be used:

• Use atomic operations to ensure thread safety.
• Use mutex locks to ensure thread safety.
• Avoid multiple threads accessing the same smart pointer simultaneously.

3. Avoid memory leaks and dangling pointers: The main purpose of smart pointers is to manage dynamically allocated memory and avoid memory leaks and dangling pointers. However, if used improperly, these problems can still occur. To avoid memory leaks and dangling pointers, the following points should be followed:

• Use smart pointers to manage dynamically allocated memory.
• Avoid using raw pointers and delete to manage memory.
• Do not manually release memory managed by smart pointers.

Example#

#include <iostream>
#include <memory>

using namespace std;

class MyClass {
public:
    void print() {
        cout << "Hello from MyClass!" << endl;
    }
};

void test_unique_ptr() {
    unique_ptr<MyClass> p(new MyClass());
    p->print();
}

void test_shared_ptr() {
    shared_ptr<MyClass> p(new MyClass());
    p->print();
}

void test_weak_ptr() {
    shared_ptr<MyClass> p1(new MyClass());
    weak_ptr<MyClass> p2(p1);
    if (!p2.expired()) {
        shared_ptr<MyClass> p3 = p2.lock();
        p3->print();
    }
}

int main() {
    test_unique_ptr();
    test_shared_ptr();
    test_weak_ptr();
    return 0;
}

In the above code, we define a class named MyClass, which has a print() method that prints a message.

Next, we define three test functions: test_unique_ptr(), test_shared_ptr(), and test_weak_ptr(). They use unique_ptr, shared_ptr, and weak_ptr smart pointer types, respectively.

In test_unique_ptr(), we use unique_ptr, which has exclusive ownership, to manage an instance of MyClass. We create this instance using the new operator and access its print() method using the arrow operator.

In test_shared_ptr(), we use shared_ptr, which allows multiple shared_ptr objects to share the same instance. We also create an instance of MyClass using the new operator and pass it to shared_ptr, which automatically tracks the reference count of the instance. Similarly, we access the instance's print() method using the arrow operator.

In test_weak_ptr(), we define a shared_ptr instance p1 and create a weak_ptr instance p2 that points to it. Since weak_ptr does not increase the reference count, it cannot directly access the MyClass instance. We need to use the lock() method to obtain a shared_ptr instance p3, which allows us to access the instance's print() method using the arrow operator.

Through the above example, we can see the usage and characteristics of different types of smart pointers. It is important to choose the most appropriate smart pointer type based on specific scenarios and requirements in actual development.

Summary#

Smart pointers are a commonly used memory management tool in C++, which can automatically manage the lifetime of objects and effectively avoid memory leaks and resource occupation. This article mainly introduces the differences between regular pointers and smart pointers, as well as the classification and characteristics of smart pointers. Each type is introduced and compared, and their applicable scenarios and considerations are pointed out.

In practical applications, it is important to choose the appropriate smart pointer type based on specific scenarios and requirements, and to avoid the pitfalls of smart pointers, such as circular references and race conditions in multi-threaded environments. Additionally, advanced techniques and tips of smart pointers, such as custom deleters and pointer conversions, can be utilized. In conclusion, smart pointers are a very useful tool in C++, helping us manage memory and resources more efficiently.

Terminology#

RAII (Resource Acquisition Is Initialization) is a C++ programming technique that uses the lifetime of objects to manage resources, including memory, files, network connections, etc. Smart pointers are an implementation of RAII for managing memory resources.

The basic principle of RAII is to acquire resources in the constructor and release them in the destructor. Smart pointers achieve automatic memory management by releasing resources in their destructors.

References#

https://learn.microsoft.com/en-us/cpp/cpp/smart-pointers-modern-cpp?view=msvc-170