Smart pointer (shared_ptr, unique_ptr, weak_ptr)

#include <iostream>
#include <memory>


int main() {
    
    // （ One ）shared_ptr
    // 1.  initialization . Smart pointer is a template class , You can specify the type , The passed in pointer is initialized by the constructor . You can also use make_shared Function initialization .
    // 2.  Cannot assign a pointer directly to a smart pointer , One is class , One is the pointer . for example std::shared_ptr<int> p4 = new int(1); It's wrong to write it in Chinese 
    // 3.  Copy and assign . Copy increases the reference count of an object 1, Assignment decrements the reference count of the original object 1, When count is 0 when , Automatically free up memory . The reference count of the object pointed to later is added 1, Point to the next object .
    // 4. get Function to get the original pointer 
    // 5.  Be careful not to initialize more than one with a single raw pointer shared_ptr, Otherwise, the same memory will be released twice 
    // 6.  Be careful to avoid circular references ,shared_ptr One of the biggest pitfalls of is circular references , loop , Circular references can cause heap memory not to be released properly , Cause memory leaks . The circular reference is in weak_ptr Described in the .
    int a = 10;
    std::shared_ptr<int> sptr(new int(10));
    std::shared_ptr<int> ptra = std::make_shared<int>(a);
    std::shared_ptr<int> ptra2(ptra); // copy
    std::cout << ptra.use_count() << std::endl;//2
    int b = 20;
    int *pb = &a;
    // std::shared_ptr<int> ptrb = pb; //  A pointer cannot be directly assigned to a smart pointer , One is class , One is the pointer 
    std::shared_ptr<int> ptrb = std::make_shared<int>(b);
    ptra2 = ptrb; // assign,ptra2 It's a copy of ptra, take ptrb Assign a value to ptra2 after ,ptra Reference count of -1
    pb = ptrb.get();
    std::cout << ptra.use_count() << std::endl;//1
    std::cout << ptrb.use_count() << std::endl;//2

    // （ Two ）unique_ptr
    // 1.  There can only be one... At a time unique_ptr Point to the given object 
    // 2. unique_ptr The life cycle of the pointer itself ： from unique_ptr When the pointer is created , Until you leave the scope .
    // 3.  When out of scope , If it points to the object , Destroy the object it refers to ( By default delete The operator , The user can specify other actions ).
    // 4. unique_ptr The relationship between a pointer and its object ： Within the life cycle of the smart pointer , You can change the object the smart pointer refers to , For example, when creating an intelligent pointer, it is specified by the constructor 、 adopt reset Method reassignment 、 adopt release Method to release ownership 、 Transfer ownership through mobile semantics .
    {
    
        std::unique_ptr<int> uptr(new int(10)); //  Binding dynamic objects 
        // std::unique_ptr<int> uptr2(uptr); //  Can't copy 
        // std::unique_ptr<int> uptr2 = uptr; //  Can't assign a value 
        std::unique_ptr<int> uptr2 = std::move(uptr);   //  Conversion ownership 
        uptr2.release();
    }
    //  exceed uptr Scope of action , Memory free 

    // （ 3、 ... and ）weak_ptr
    // 1.  In order to cooperate shared_ptr Smart pointer just introduced , It doesn't have the behavior of ordinary pointers , No overloading operator* and ->, Its greatest function is to help shared_ptr Work , Observe the use of resources like a bystander .
    // 2. weak_ptr Can be from a shared_ptr Or another weak_ptr Object construction , Get the right to observe resources . but weak_ptr No shared resources , Its construction does not cause the pointer reference count to increase .
    // 3.
    {
    
        std::shared_ptr<int> sh_ptr = std::make_shared<int>(10);
        std::cout << sh_ptr.use_count() << std::endl;//1

        std::weak_ptr<int> wp(sh_ptr); //  Use shared_ptr structure 
        std::cout << wp.use_count() << std::endl;//1

        if (!wp.expired())// Member functions expired() The function of is equivalent to use_count()==0
        {
    
            // weak_ptr You can use a very important member function lock() From the observed shared_ptr Get a usable shared_ptr object ,  To operate resources .
            //  But when expired()==true When ,lock() Function will return a null pointer shared_ptr.
            std::shared_ptr<int> sh_ptr2 = wp.lock(); // get sh_ptr
            *sh_ptr = 100;
            std::cout << wp.use_count() << std::endl; //2
        }
    }
    // Memory free 

    return 0;
}