#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); // 注意：可能會(huì)被NRVO優(yōu)化掉
        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是一個(gè)左值

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

    MyClass a3(a1); // copy construct  注：a1是一個(gè)左值
    MyClass&& a4 = MyClass::GetMyClassGo("go"); // move construct  注：發(fā)生在MyClass::GetMyClassGo()內(nèi)部
    MyClass a5 = MyClass::GetMyClassGo("china"); // move construct兩次  注：一次發(fā)生在MyClass::GetMyClassGo()內(nèi)部；另一次發(fā)生在將返回值賦值給a5
    
    MyClass a6("let");
    MyClass a7("it");
    MyClass a8("go");
    MyClass a9("!");

    func0(a6);  // copy construct
    func1(a7);
    func2(a8);
    //func3(a9); // 編譯error: 不能把一個(gè)左值賦值給右值

    func0(MyClass::GetMyClassGo("god")); // move construct兩次  注：一次發(fā)生在MyClass::GetMyClassGo()內(nèi)部；另一次發(fā)生在將返回值賦值給foo0參數(shù)時(shí)
    //func1(MyClass::GetMyClassGo("is")); // 編譯error: 不能把一個(gè)右值賦值給左值
    func2(MyClass::GetMyClassGo("girl")); // move construct  注：發(fā)生在MyClass::GetMyClassGo()內(nèi)部
    func3(MyClass::GetMyClassGo("!"));  // move construct  注：發(fā)生在MyClass::GetMyClassGo()內(nèi)部

    return 0;
}

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


/*****************************************
std::remove_reference功能為去除類(lèi)型中的引用

std::remove_reference<T &>::type ---> T
std::remove_reference<T &&>::type ---> T
std::remove_reference<T>::type ---> T
******************************************/
//原始的，最通用的版本
template <typename T> struct remove_reference{
    typedef T type;  //定義T的類(lèi)型別名為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轉(zhuǎn)發(fā)前后，參數(shù)a，b的類(lèi)型完全不變
}

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

    foo(a, 20); // 展開(kāi)為void foo(int& a, int&& b)，經(jīng)過(guò)std::forward完美轉(zhuǎn)發(fā)后，會(huì)調(diào)用到void bar(int& a, int&& b)函數(shù)

    func(std::forward<int>(a), std::forward<int&&>(30)); // 經(jīng)過(guò)std::forward完美轉(zhuǎn)發(fā)后，會(huì)調(diào)用到void func(int a, int&& b)函數(shù)

    return 0;
}