2-8. lvalue and rvalue References

左值引用与右值引用

C++左值性的定义: 一个表达式不是左值就是右值,与C完全不一样。

C/C++中的类型系统可以有多种划分方法，例如基本类型与复合类型（也叫派生类型）、标量类型与聚集类型，

还有一种是根据对象模型来分，分为对象类型、不完整类型、函数类型和引用类型（C没有引用类型），

由于C++规定引用类型属于左值，同时也把函数纳入左值范畴，因此C++的左值包括了对象模型划分方法中的所有类型，

再使用类似C那种左值定义方法是多余的，C++仅需要指出一个表达式不是左值就是右值就行了，但C就不行，因为C

存在既不是左值也不是右值的表达式：函数指示符。所以引申出左值引用和右值引用

& (lvalue) and && (rvalue)，这两个引用引用的目的是取代copying objects，用于move semantics。

an rvalue reference should be used to move construct or move assign objects in place of copy operations where appropriate.

Move semantics should not be used to replace passing parameters to methods by const reference.

A move operation could be faster than a copy, in the worst case it can be slower than a copy and it will always be slower than passing by const reference.

在进行copy操作时，使用move操作进行取代。一般来说不用使用move操作替换const引用，

move操作一般比copy快，极端情况下可能比copy慢，但是肯定比const reference慢。

 １．A Class that Counts the Number of Instances

#include <iostream>

using namespace std;

class MyClass
{
private:
    static int s_Counter;

    int* m_Member{ &s_Counter };

public:
    MyClass()
    {
        ++(*m_Member);
    }

    ~MyClass()
    {
        --(*m_Member);
        m_Member = nullptr;
    }

    int GetValue() const
    {
        return *m_Member;
    }
};

int MyClass::s_Counter{ 0 };

int main()
{
    auto object1 = MyClass();
    cout << object1.GetValue() << endl;

    {
        auto object2 = MyClass();
        cout << object2.GetValue() << endl;
    }

    auto object3 = MyClass();
    cout << object3.GetValue() << endl;

    return 0;
｝

２． Copying MyClass

#include <iostream>

using namespace std;

class MyClass
{
private:
    static int s_Counter;

    int* m_Member{ &s_Counter };

public:
    MyClass()
    {
        ++(*m_Member);
        cout << "Constructing: " << GetValue() << endl;
    }

    ~MyClass()
    {
        --(*m_Member);
        m_Member = nullptr;

        cout << "Destructing: " << s_Counter << endl;
    }

    MyClass(const MyClass& rhs)
        : m_Member{ rhs.m_Member }
    {
        ++(*m_Member);
        cout << "Copying: " << GetValue() << endl;
    }

    int GetValue() const
    {
        return *m_Member;
    }
};

int MyClass::s_Counter{ 0 };

MyClass CopyMyClass(MyClass parameter)
{
    return parameter;
}

int main()
{
    auto object1 = MyClass();

    {
        auto object2 = MyClass();
    }

    auto object3 = MyClass();
    auto object4 = CopyMyClass(object3);

    return 0;
}

Move constructors can be utilized to cut down on the complexity of a copy constructor.

A rvalue reference is a guarantee from the compiler that the object referenced by the variable was a temporary object.

This means that you are free to cannibalize the object so that you can implement a copy operation faster than if the

pre-existing state was needed to bepreserved. 

move操作降低了copy constructor的复杂度，右值引用就是让编译器确认零时变量能够进行拷贝

３． Adding a Move Constructor to MyClass

#include <iostream>

using namespace std;

class MyClass
{
private:
    static int s_Counter;
    int* m_Member{ &s_Counter };

public:
    MyClass()
    {
        ++(*m_Member);
        cout << "Constructing: " << GetValue() << endl;
    }

    ~MyClass()
    {
        if (m_Member)
        {
            --(*m_Member);
            m_Member = nullptr;
            cout << "Destructing: " << s_Counter << endl;
        }
        else
        {
            cout << "Destroying a moved-from instance" << endl;
        }
    }

    MyClass(const MyClass& rhs)
        : m_Member{ rhs.m_Member }
    {
        ++(*m_Member);
        cout << "Copying: " << GetValue() << endl;
    }

    MyClass(MyClass&& rhs)
        : m_Member{ rhs.m_Member }
    {
        cout << hex << showbase;
        cout << "Moving: " << &rhs << " to " << this << endl;
        cout << noshowbase << dec;
        rhs.m_Member = nullptr;
    }
    int GetValue() const
    {
        return *m_Member;
    }
};

int MyClass::s_Counter{ 0 };

MyClass CopyMyClass(MyClass parameter)
{
    return parameter;
}

int main()
{
    auto object1 = MyClass();

    {
        auto object2 = MyClass();
    }

    auto object3 = MyClass();
    auto object4 = CopyMyClass(object3);

    return 0;
}

４．Comparing Copy Constructors with Move Constructors

#include <chrono>
#include <iostream>
#include <string>
#include <vector>

using namespace std;
using namespace chrono;
using namespace literals;

class MyClass
{
private:
    vector<string> m_String{
        "This is a pretty long string that"
        " must be copy constructed into"
        " copyConstructed!"s
    };

    int m_Value{ 1 };

public:
    MyClass() = default;
    MyClass(const MyClass& rhs) = default;
    MyClass(MyClass&& rhs) = default;

    int GetValue() const
    {
        return m_Value;
    }
};

int main()
{
    using MyVector = vector<MyClass>;
    constexpr unsigned int ITERATIONS{ 1000000U };

    MyVector copyConstructed(ITERATIONS);
    int value{ 0 };

    auto copyStartTime = high_resolution_clock::now();
    for (unsigned int i=0; i < ITERATIONS; ++i)
    {
        MyClass myClass;
        copyConstructed.push_back(myClass);
        value = myClass.GetValue();
    }
    auto copyEndTime = high_resolution_clock::now();

    MyVector moveConstructed(ITERATIONS);

    auto moveStartTime = high_resolution_clock::now();
    for (unsigned int i=0; i < ITERATIONS; ++i)
    {
        MyClass myClass;
        moveConstructed.push_back(move(myClass));
        value = myClass.GetValue();
    }
    auto moveEndTime = high_resolution_clock::now();

    cout << value << endl;

    auto copyDuration =　duration_cast<milliseconds>(copyEndTime - copyStartTime);
    cout << "Copy lasted: " << copyDuration.count() << "ms" << endl;

    auto moveDuration =
        duration_cast<milliseconds>(moveEndTime - moveStartTime);
    cout << "Move lasted: " << moveDuration.count() << "ms" << endl;

    return 0;
}