int main()
{
    // 以下的p、b、c、*p都是左值
    int* p = new int(0);
    int b = 1;
    const int c = 2;
    
    // 以下几个是对上面左值的左值引用
    int*& rp = p;
    int& rb = b;
    const int& rc = c;
    int& pvalue = *p;
    
    return 0; 
}	

int main()
{
    double x = 1.1, y = 2.2;
    
    // 以下几个都是常见的右值
    10; 
    x + y; 		// 因为表达式返回的值是临时的，所以是没办法取地址的
    fmin(x, y); // 函数调用也是没办法取地址的
    
    // 以下几个都是对右值的右值引用
    int&& rr1 = 10;
    double&& rr2 = x + y;
    double&& rr3 = fmin(x, y);
    
    // 这里编译会报错：error C2106: “=”: 左操作数必须为左值
    10 = 1; 
    x + y = 1;
    fmin(x, y) = 1;
    
    return 0; 
}

int main()
{
     double x = 1.1, y = 2.2;
     int&& rr1 = 10;
     const double&& rr2 = x + y;
    
     rr1 = 20;
     rr2 = 5.5;  // const属性，修改会报错
    
     return 0; 
}

int main()
{
    // 非const左值引用只能引用左值，不能引用右值。
    int a = 10;
    int& ra1 = a;     // ra为a的别名
    //int& ra2 = 10;  // 编译失败，因为10是右值
    
    // const左值引用既可引用左值，也可引用右值。
    const int& ra3 = 10;
    const int& ra4 = a;
    
    return 0; 
}

int main()
{
    // 右值引用只能右值，不能引用左值。
    int&& r1 = 10;
 
    // error C2440: “初始化”: 无法从“int”转换为“int &&”
    // message : 无法将左值绑定到右值引用
    int a = 10;
    int&& r2 = a;  // ❌
    
    // 右值引用可以引用move以后的左值
    int&& r3 = std::move(a);
    
    return 0; 
}

class string
{
public:
    string(const char* str = "")
        :_size(strlen(str))
        , _capacity(_size)
    {
        //cout << "string(char* str)" << endl;
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }
 
    // 拷贝构造
    string(const string& s)
        :_str(nullptr)
    {
        string tmp(s._str);
        swap(tmp);
    }
 
    // 赋值重载
    string& operator=(const string& s)
    {
        string tmp(s);
        swap(tmp);
        return *this;
    }
 
    string operator+(char ch)
    {
        string tmp(*this);
        push_back(ch);
        return tmp;
    }
 
    ~string() { if (_str) delete[] _str;}
private:
    char* _str;
    size_t _size;
    size_t _capacity;
};
int main()
{
    string s1("hello");
    string s2("world");
    string s3(s1+s2);
    return 0; 
}

// string的移动构造
string(string&& s)
    :_str(nullptr)
    ,_size(0)
    ,_capacity(0)
{
	this->swap(s);  
}
 
// string的拷贝构造
string(const string& s)
    :_str(nullptr)
    ,_size(0)
    ,_capacity(0)
{
    string tmp(s._str);
    this->swap(tmp);
}

// 移动赋值（在类内实现）
string& operator=(string&& s) 
{
    cout << "string& operator=(string&& s) -- 移动语义" << endl;
    this->swap(s);
    return *this; 
}
 
int main()
{
    liren::string ret1;
    ret1 = liren::to_string(1234);
    return 0; 
}
 
// 运行结果：
// string(string&& s) -- 移动语义
// string& operator=(string&& s) -- 移动语义

// move的函数定义如下所示：
template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
    // forward _Arg as movable
    return ((typename remove_reference<_Ty>::type&&)_Arg);
}
 
int main()
{
    liren::string s1("hello world");
    
    // 这里s1是左值，调用的是拷贝构造！
    liren::string s2(s1);
    
    // 这里我们把s1进行move处理以后, 会被当成右值，调用的是移动构造！
    // 但是这里要注意，一般是不要这样用的，因为我们会发现s1的资源被转移给了s3，而s1就被置空了！
    liren::string s3(std::move(s1));
    return 0; 
}

void Fun(int &x)	   { cout << "左值引用" << endl; }
void Fun(const int &x) { cout << "const 左值引用" << endl; }
 
void Fun(int &&x)		{ cout << "右值引用" << endl; }
void Fun(const int &&x) { cout << "const 右值引用" << endl; }
 
// 下面模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 而引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 但我们希望能够在传递过程中保持它的左值或者右值的属性, 所以就需要用我们学习完美转发机制
template<typename T>
void PerfectForward(T&& t) 
{
    Fun(t);
}
 
int main()
{
    PerfectForward(10);           // 右值
    
    int a;
    PerfectForward(a);            // 左值
    PerfectForward(std::move(a)); // 右值
    
    const int b = 8;
    PerfectForward(b);      // const 左值
    PerfectForward(std::move(b)); // const 右值
    return 0; 
}
 
//运行结果：
左值引用
左值引用
左值引用
const 左值引用
const 左值引用

void Fun(int &x)	   { cout << "左值引用" << endl; }
void Fun(const int &x) { cout << "const 左值引用" << endl; }
 
void Fun(int &&x)		{ cout << "右值引用" << endl; }
void Fun(const int &&x) { cout << "const 右值引用" << endl; }
 
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t) 
{
    Fun(std::forward<T>(t));
}
 
int main()
{
    PerfectForward(10);           // 右值
    int a;
    PerfectForward(a);            // 左值
    PerfectForward(std::move(a)); // 右值
    const int b = 8;
    PerfectForward(b);      // const 左值
    PerfectForward(std::move(b)); // const 右值
    return 0;
}
 
// 运行结果
右值引用
左值引用
右值引用
const 左值引用
const 右值引用

template<class T>
struct ListNode
{
    ListNode* _next = nullptr;
    ListNode* _prev = nullptr;
    T _data;
};
template<class T>
class List
{
    typedef ListNode<T> Node;
public:
    List()
    {
        _head = new Node;
        _head->_next = _head;
        _head->_prev = _head;
    }
    void PushBack(T&& x)
    {
        //Insert(_head, x);
        Insert(_head, std::forward<T>(x)); // 关键位置,使用std::forward
    }
    void PushFront(T&& x)
    {
        //Insert(_head->_next, x);
        Insert(_head->_next, std::forward<T>(x)); // 关键位置,使用std::forward
    }
    void Insert(Node* pos, T&& x)
    {
        Node* prev = pos->_prev;
        Node* newnode = new Node;
        newnode->_data = std::forward<T>(x); // 关键位置,使用std::forward，保证如果是自定义类型的话调用移动赋值
        
        // prev newnode pos
        prev->_next = newnode;
        newnode->_prev = prev;
        newnode->_next = pos;
        pos->_prev = newnode;
    }
    void Insert(Node* pos, const T& x)
    {
        Node* prev = pos->_prev;
        Node* newnode = new Node;
        newnode->_data = x; // 关键位置，接收的是左值，不需要完美转发
        
        // prev newnode pos
        prev->_next = newnode;
        newnode->_prev = prev;
        newnode->_next = pos;
        pos->_prev = newnode;
    }
private:
 	Node* _head;
};
int main()
{
    List<liren::string> lt;
    lt.PushBack("1111");
    lt.PushFront("2222");
    return 0; 
}
 
// 运行结果
string& operator=(string&& s) -- 移动语义
string& operator=(string&& s) -- 移动语义