Dynamic memory and smart pointer

One 、 Three memory areas

Stack memory ： Save the non-linear data defined in the function static object .

Static memory ： Save local static object , class static Data members and variables defined outside any function .

Pile up （ Free space ）： Store dynamically allocated objects .

Programs use dynamic memory for one of three reasons ：

1、 The program doesn't know how many objects it needs to use

2、 The program does not know the exact type of the required object

3、 Programs need to share data among multiple objects

Two 、 Dynamic memory and smart pointer

The header file ：memory

1、 Operator new、delete

    new： Allocate space for the object in dynamic memory and return a pointer to the object .

    delete： Receive a pointer to a dynamic object , Destroy object , And release the memory associated with it .

2、shared_ptr class

#include<memory>
#include<string>
using namespace std;
int main()
{
        shared_ptr<string> p;
        // If p Not empty , Check if it points to an empty string
        if (p && p->empty())
        {
        }
        return 0;
}

     Every shared_ptr There is an associated counter , It is called reference counting . The calculator records how many smart pointers an object is pointed to .shared_ptr The destructor of decrements the reference count of the object it points to . If the reference count changes to 0,shared_ptr The destructor will destroy the object , And release

perform delete After operator , First call the destructor of the object , Free memory after

Appoint d( replace delete) after , When the object should be released d( Even if there was a destructor , Is also called d Instead of calling the original function ), stay d Required in delete Operator to free memory .

#include<memory>
#include<string>
#include"test.h"
#include"testClass.h"
using namespace std;
void f(testClass* p)
{
    cout << "f" << endl;
    delete p;
}
int main()
{
    testClass* p;
    if (true)
    {
        shared_ptr<testClass> sp(new testClass("123"),f);
        p = sp.get();
    }
    p->name = "456";// And release , Cannot execute correctly 
    return 0;
}

（1） When the reference count of an object is 0, But when there are other pointers pointing to it , Whether the object will be destroyed ？

answer ： Will destroy

（2）make_shared function

    The safest method of dynamic memory allocation is to call make_shared The standard library function of . This function allocates an object in dynamic memory and initializes it , Returns... Pointing to this object shared_ptr.

shared_ptr<string> p1 = make_shared<string>();
auto p2 = make_shared<string>("CDA");

3、unique_ptr class

    There can only be one at a time unique_ptr Point to a given object , When unique_ptr Be destroyed when the , The object it points to is also destroyed .

    

    Because there can only be one at a time unique_ptr Point to a given object , So you can't copy unique_ptr, But there is one exception , We can copy or assign a value to be destroyed unique_ptr. for example ：

notes ：

towards unique_ptr Pass delete

unique_ptr< object type , Delete type > p(new For object types , Remover );

  

（1） Can you make a unique_ptr And a shared_ptr Point to the same object

An error occurred while running .

Conclusion ：unique_ptr After pointing to an object , There can be no smart pointer to the object .

4、weak_ptr

    weak_ptr Is an intelligent pointer that does not control the lifetime of the object it points to , It points to by a shared_ptr The object of Management . Will a weak_ptr Bind to a shared_ptr Will not change shared_ptr Reference count of . Once the last one points to the object shared_ptr Be destroyed , The object is released . Even if there is weak_ptr Point to object , The object will still be released .

Because the object may not exist , We can't use weak_ptr Direct access to objects , You have to call lock.

weak_ptr<string> wp(make_shared<string>("123"));
if (auto sp = wp.lock())// Determine whether it is null 
{

}

5、 Use standard

delete After memory, assign the pointer to nullptr, Indicates that the pointer is no longer bound to any object