Right value reference and mobile construction

Right quoting

 Concept ： The left value ： The quantity with address is the lvalue .
           Right value ： No address quantity is the right value .
 Constants are stored in registers   So there is no address, only space . To reference constants, you have to   Add const
 for example  const int & i =10;
 Again   We can also use it to deal with class objects , When a class object is initialized by a temporary object , Because temporary objects will be destroyed after the code runs , So the reference failed , Although added const  Can solve  const A& a = B(), But we can't assign the member attribute of this object . And constant objects can only access constant functions ,（ In actual development, we can't require others' class member functions to become constant functions ）. So we change the regular reference to the temporary object to the right value reference  A&& a = B();, You can extend the lifetime of temporary objects , You can access base class member functions at will , You can override the member properties of this object . See code for details ：

#include <iostream>
using namespace std;
class A
{
    
public:
    A()
    {
    
        cout << "A Construction " << endl;
    }
    A(const A&)
    {
    
        cout << "A Copy construction of " << endl;
    }
    virtual ~A()
    {
    
        cout << "A The analysis of " << endl;
    }
    virtual void showInfo()
    {
    
        cout << " you   good   ah " << endl;
    }
};
class B : public A
{
    
public:
    B()
    {
    
        cout << "B Construction " << endl;
    }
    ~B()
    {
    
        cout << "B The analysis of " << endl;
    }
    void showInfo()override
    {
    
        cout << " classmate ！ come on. ！！！！" << endl;
    }
};
int main()
{
    

// const int& a = 10; //int temp = 10, const int& = temp;
    // Lvalue reference is also called constant reference .
// const A& a = B();


    A&& a = B();// The right value refers to one of the application scenarios   Temporary objects trigger polymorphism 
    a.showInfo();
    // After using the right reference, you can't only access constant functions  
    // and   This object can also be assigned   Embodied in the mobile structure 
    A&& a1 = std::move(a);// Initialize objects with existing objects  move  In fact, what is returned is a temporary object   Trigger polymorphism 
    a1.showInfo();
    return 0;
}

 Mobile semantic function std::move( The left value ) Use ： It is mainly used to move the spatial resources of lvalues .

#include <iostream>
using namespace std;
class A
{
    
private:
    int* p;
public:
    A():p(new int[1024])
    {
    
        cout << "A Construction " << endl;
    }
    A(const A& other)
    {
    
        this->p = new int[1024];
        memcpy(this->p,other.p,sizeof(int[1024]));
        cout << "A Copy construction of " << endl;
    }
    A(A&& other)// The reason why the right value reference is passed in is because   The internal implementation needs to control the parameters passed in   To operate 
    {
    
        this->p = other.p;
        other.p = nullptr;
        cout << "A Mobile structure of " << endl;
    }
    ~A()
    {
    
        if(p != nullptr)
        {
    
            delete [] p;
            p = nullptr;
        }
        cout << "A The analysis of " << endl;
    }
};

int main()
{
    
    A a;
    A a1 = std::move(a);// Improve the efficiency of copy construction   It's actually an implicit structure   If you don't write the mobile structure   What is called is a copy construct 
    //A&& a1 = std::move(a);  In fact, it is also an alias 
}