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

This article mainly explains "how to use C++ smart pointer". Interested friends may wish to have a look at it. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn how to use C++ smart pointers.

1. What is a smart pointer?

C++ smart pointers are classes that contain overloaded operators and behave like regular pointers, but smart pointers are more valuable because they can timely and properly destroy dynamically allocated data and implement a clear object life cycle.

Problems with conventional pointers

C++ provides comprehensive flexibility in memory allocation, release, and management; on the other hand, it may cause memory-related problems, such as memory leaks if dynamically allocated objects are not properly released.

The function of intelligent pointer

Smart pointers behave like regular pointers, but provide more useful functions by overloading operators and destructors to ensure that dynamically allocated data is destroyed in a timely manner.

Smart_pointer spDate = mObject.GetData ()

SpData- > Display ()

(* spData) .Display ()

two。 Realization of Intelligent pointer

The smart pointer class overloads the de-reference operator (*) and member selection operator (- >) so that they can be used like regular pointers. The following shows the implementation of a simple smart pointer class:

Template class smart_pointer {private: T* pData: m_pRawPointer (pData) {} / / constructor ~ smart_pointer () {delete pData;}; / / destructor smart_pointer (const smart_pointer& anotherSP); / / copy constructor smart_pointer& operator= (const smart_pointer& anotherSP) T & operator* () const {return * (m_pRawPointer);} T * operator () const {return masked pRawPoint;}; 3. Smart pointer type

Smart pointers determine how to handle memory resources when copying and assigning values. The classification of smart pointers is actually the classification of memory resource management strategies. It can be divided into the following categories:

Deep copy, copy-on-write, reference count, reference link, destructive copy.

Deep replication

In smart pointers that implement deep replication, each smart pointer instance keeps a complete copy of the objects it manages. Whenever a smart pointer is copied, the object it points to is copied. Whenever the smart pointer leaves the scope, the memory it points to is freed.

Although smart pointers based on deep copy do not seem superior to passing objects by value, their advantages will be shown when dealing with polymorphic objects.

The following demonstrates the ability to pass polymorphic objects as base class objects using smart pointers based on deep replication.

Templateclass deepcopy_smart_pointer {private: T* mroompObjective devise copycat smartphones (const deepcopy_smart_pointer& source) / / copy constructor {m_pObject = source- > Clone ();} deep_smart_pointer& operator= (const deepcopy_smart_pointer& source) / / copy assignment operator {if (m_pObject) assignment operator MumpObjectSource-> Clone ();}; 4. Use std::unique_ptr

Std::unique_ptr is a simple smart pointer, but its copy constructor and assignment operator are declared private, so it cannot be copied, that is, it cannot be passed to a function by value, nor can it be assigned to another pointer.

Unique_ptr is new to Clippers 11, which is slightly different from auto_ptr because it does not allow replication and assignment. To use std::unique_ptr, you must include a header file:

# include

The following shows how to use the simplest smart pointer:

# include # include using namespace std;class Fish {public:Fish () {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.