Shulou(Shulou.com)06/03 Report--

This article mainly introduces "the use of C++ smart pointers". In daily operation, I believe many people have doubts about the use of C++ smart pointers. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful for you to answer the doubts about the use of C++ smart pointers. Next, please follow the editor to study!

Catalogue

1. RAII and reference count

II. Std::shared_ptr

III. Std::unique_ptr

IV. Std::weak_ptr

V. Summary

1. RAII and reference count

Programmers who know Objective-C/Swift should know the concept of reference counting. Reference counting this count is made to prevent memory leaks.

The basic idea is to count references to dynamically allocated objects. Each time you add a reference to the same object, the reference count of the reference object increases, and each time you delete a reference, the reference count decreases by one. When an object's reference count is reduced to 00:00, the heap memory that it points to is automatically deleted.

In traditional C++, "remember" to release resources manually is not always a best practice. Because we are likely to forget to release resources and lead to leakage. So the usual practice is for an object, we apply for space when we construct the function, and free up space when the destructor (called when it leaves scope), which is what we often call RAII resource acquisition or initialization technology.

There are always exceptions. There is always a need to allocate objects to free storage. In traditional C++, we have to use new and delete to "remember" to release resources. Clocked 11 introduces the concept of smart pointers and uses the idea of reference counting so that programmers no longer need to worry about freeing memory manually.

These smart pointers include std::shared_ptr std::unique_ptr std::weak_ptr, and you need to include header files to use them.

Note: reference counting is not garbage collection, reference counting can recover objects that are no longer used as soon as possible, at the same time, it will not cause a long wait in the process of recycling, and can clearly indicate the life cycle of resources.

II. Std::shared_ptr

Std::shared_ptr is a smart pointer that records how many shared_ptr jointly point to an object, eliminating the explicit call to delete, which automatically deletes the object when the reference count changes to zero.

But it's not enough, because you still need to use new to call to use std::shared_ptr, which makes the code somewhat asymmetric.

Std::make_shared can be used to eliminate the explicit use of new, so std::make_shared allocates to create the object in the passed-in parameters and returns a std::shared_ptr pointer of that object type. For example:

# include # include void foo (std::shared_ptr I) {(* I) +;} int main () {/ / auto pointer = new int (10); / / illegal, no direct assignment / / Constructed a std::shared_ptr auto pointer = std::make_shared (10); foo (pointer); std::cout

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.