详解C++右值引用

#include <iOStream>
#include <string>
#include <utility>

struct MyClass
{
    std::string s;
    MyClass(const char* sz) : s(sz) 
    {
        std::cout << "MyClass sz:" << sz << std::endl;
    }
    MyClass(const MyClass& o) : s(o.s) 
    { 
        std::cout << "copy construct!\n"; 
    }

    MyClass(MyClass&& o) noexcept : s(std::move(o.s)) 
    {
        std::cout << "move construct!\n";
    }

    MyClass& operator=(const MyClass& other) { // copy assign
        std::cout << "copy assign!\n";
        s = other.s;
        return *this;
    }
    MyClass& operator=(MyClass&& other) noexcept { // move assign
        std::cout << "move assign!\n";
        s = std::move(other.s);
        return *this;
    }

    static MyClass GetMyClassGo(const char* sz)
    {
        MyClass o(sz); // 注意：可能会被NRVO优化掉
        return o;
    }
};

void func0(MyClass o)
{
    std::cout << o.s.c_str() << std::endl;
}

void func1(MyClass& o)
{
    std::cout << o.s.c_str() << std::endl;
}

void func2(const MyClass& o)
{
    std::cout << o.s.c_str() << std::endl;
}

void func3(MyClass&& o)
{
    std::cout << o.s.c_str() << std::endl;
}

int main(int arg, char* argv[])
{
    MyClass a1("how");
    MyClass a2("are");

    a2 = a1; // copy assign  注：a1是一个左值

    a2 = MyClass("you"); // move assign  注：MyClass("you")是一个右值

    MyClass a3(a1); // copy construct  注：a1是一个左值
    MyClass&& a4 = MyClass::GetMyClassGo("go"); // move construct  注：发生在MyClass::GetMyClassGo()内部
    MyClass a5 = MyClass::GetMyClassGo("china"); // move construct两次  注：一次发生在MyClass::GetMyClassGo()内部；另一次发生在将返回值赋值给a5
    
    MyClass a6("let");
    MyClass a7("it");
    MyClass a8("go");
    MyClass a9("!");

    func0(a6);  // copy construct
    func1(a7);
    func2(a8);
    //func3(a9); // 编译error: 不能把一个左值赋值给右值

    func0(MyClass::GetMyClassGo("god")); // move construct两次  注：一次发生在MyClass::GetMyClassGo()内部；另一次发生在将返回值赋值给foo0参数时
    //func1(MyClass::GetMyClassGo("is")); // 编译error: 不能把一个右值赋值给左值
    func2(MyClass::GetMyClassGo("girl")); // move construct  注：发生在MyClass::GetMyClassGo()内部
    func3(MyClass::GetMyClassGo("!"));  // move construct  注：发生在MyClass::GetMyClassGo()内部

    return 0;
}

template <typename T>
typename remove_reference<T>::type&& move(T&& t)
{
    return static_cast<typename remove_reference<T>::type &&>(t);
}



//原始的，最通用的版本
template <typename T> struct remove_reference{
    typedef T type;  //定义T的类型别名为type
};
 
//部分版本特例化，将用于左值引用和右值引用
template <class T> struct remove_reference<T&> //左值引用
{ typedef T type; }
 
template <class T> struct remove_reference<T&&> //右值引用
{ typedef T type; }

template <typename T>
T&& forward(remove_reference_t<T>& arg) // forward an lvalue as either an lvalue or an rvalue
{ 
    return static_cast<T&&>(arg);
}

template <typename T>
T&& forward(remove_reference_t<T>&& arg) // forward an rvalue as an rvalue
{ 
    static_assert(!is_lvalue_reference_v<T>, "bad forward call");
    return static_cast<T&&>(arg);
}

void bar(int& a, int&& b)
{
    int c = a + b;
}

void func(int a, int&& b)
{
    int c = a + b;
}

template <typename A, typename B>
void foo(A&& a, B&& b) { // a, b为左值引用或右值引用
    bar(std::forward<A>(a), std::forward<B>(b)); // 在std::forward转发前后，参数a，b的类型完全不变
}

int main(int arg, char* argv[])
{
    int a = 10;

    foo(a, 20); // 展开为void foo(int& a, int&& b)，经过std::forward完美转发后，会调用到void bar(int& a, int&& b)函数

    func(std::forward<int>(a), std::forward<int&&>(30)); // 经过std::forward完美转发后，会调用到void func(int a, int&& b)函数

    return 0;
}