// 左值例子:
int a = 42;        // a是左值，&a是合法的
int arr[5];        // arr是左值，&arr是合法的
int *p = &a;       // p是左值，&p是合法的
a = 100;           // a可以出現(xiàn)在等號(hào)左邊，是個(gè)"可修改的左值"
const int c = 10;  // c是左值但不可修改，是個(gè)"不可修改的左值"

// 右值例子:
int b = a + 1;     // a+1是右值，你不能寫(xiě)&(a+1)
int d = 42;        // 字面量42是右值，你不能寫(xiě)&42
func();            // 函數(shù)返回值是右值（除非返回引用）

int a = 42;
int& ref = a;  // 左值引用，綁定到左值
ref = 100;     // 修改ref實(shí)際上就是修改a
std::cout << a;  // 輸出100，原變量被修改了

// 下面這些是錯(cuò)誤的用法
// int& invalid_ref;        // 錯(cuò)誤：引用必須初始化  
// int& ref_to_literal = 42; // 錯(cuò)誤：不能綁定到字面量（右值）

int x = 42;
const int& ref1 = x;    // 綁定到左值，沒(méi)問(wèn)題
const int& ref2 = 42;   // 綁定到右值，也沒(méi)問(wèn)題！
const int& ref3 = x+1;  // 綁定到表達(dá)式結(jié)果，也可以！

void printValue(const std::string& s) {  // 既能接受左值又能接受右值
    std::cout << s << std::endl;
}

std::string str = "hello";
printValue(str);             // 左值：沒(méi)問(wèn)題
printValue(str + " world");  // 右值：也沒(méi)問(wèn)題！

int&& rref = 42;       // 右值引用，綁定到右值
int x = 10;
// int&& bad_ref = x;  // 錯(cuò)誤：右值引用不能直接綁定到左值

int&& rref = 42;  // rref的類(lèi)型是右值引用(int&&)，但rref本身是個(gè)左值
int& ref = rref;  // 正確！因?yàn)閞ref雖然類(lèi)型是右值引用，但它是個(gè)有名字的變量，所以是左值

void foo(int&& x) {
    x = 100;  // x在函數(shù)內(nèi)部是左值！盡管它的類(lèi)型是右值引用
}

void foo(int& x) {
    // 參數(shù)必須是左值
}

void bar(int&& x) {
    // 參數(shù)必須是右值
    // 但x本身在函數(shù)內(nèi)部是左值（因?yàn)樗忻郑?}

int main() {
    int a = 5;
    foo(a);     // 正確，a是左值
    // foo(10);    // 錯(cuò)誤，10是右值
    
    bar(10);    // 正確，10是右值
    // bar(a);     // 錯(cuò)誤，a是左值
}

class MyString {
private:
    char* data;
    size_t length;
public:
    // 構(gòu)造函數(shù)
    MyString(constchar* str) {
        length = strlen(str);
        data = newchar[length + 1];
        strcpy(data, str);
    }
    
    // 析構(gòu)函數(shù)
    ~MyString() {
        delete[] data;
    }
    
    // ... 其他成員
};

// 復(fù)制構(gòu)造函數(shù)
MyString(const MyString& other) {
    length = other.length;
    data = newchar[length + 1];
    strcpy(data, other.data);  // 復(fù)制內(nèi)容，開(kāi)辟新內(nèi)存
}

// 復(fù)制賦值運(yùn)算符
MyString& operator=(const MyString& other) {
    if (this != &other) {
        delete[] data;  // 釋放原有資源
        length = other.length;
        data = newchar[length + 1];
        strcpy(data, other.data);  // 復(fù)制內(nèi)容，開(kāi)辟新內(nèi)存
    }
    return *this;
}

MyString createGreeting() {
    MyString greeting("Hello, world!");
    return greeting;  // 返回時(shí)會(huì)創(chuàng)建臨時(shí)對(duì)象
}

void useString() {
    MyString s = createGreeting();  // 從臨時(shí)對(duì)象復(fù)制構(gòu)造
    // 臨時(shí)對(duì)象隨后被銷(xiāo)毀
}

// 移動(dòng)構(gòu)造函數(shù)
MyString(MyString&& other) noexcept {
    length = other.length;
    data = other.data;         // 直接偷走指針
    other.data = nullptr;      // 把被偷的對(duì)象標(biāo)記為"已被偷"
    other.length = 0;
}

// 移動(dòng)賦值運(yùn)算符
MyString& operator=(MyString&& other) noexcept {
    if (this != &other) {
        delete[] data;         // 釋放自身原有資源
        length = other.length;
        data = other.data;     // 偷走other的資源
        other.data = nullptr;  // 標(biāo)記other為"已被偷"狀態(tài)
        other.length = 0;
    }
    return *this;
}

MyString createGreeting() {
    MyString greeting("Hello, world!");
    return greeting;  // 返回時(shí)會(huì)創(chuàng)建臨時(shí)對(duì)象
}
void useString() {
    MyString s = createGreeting();  // 現(xiàn)在可以移動(dòng)構(gòu)造，而不是復(fù)制
}

MyString source("Hello");
MyString dest = std::move(source);  // 移動(dòng)構(gòu)造

// 此時(shí)source仍然是有效的對(duì)象，但它的內(nèi)容是什么？
// 我們只知道它不再擁有原來(lái)的字符串資源，但具體狀態(tài)不確定
// 你可以對(duì)source賦新值，但不應(yīng)該使用它的當(dāng)前值

// 此時(shí)直接使用source是危險(xiǎn)的
std::cout << source.data;    // 危險(xiǎn)！source可能已經(jīng)是空指針

// 但給source賦新值是安全的
source = MyString("World");  
// 賦值后，使用source又變得安全了
std::cout << source.data;    // 現(xiàn)在安全了，因?yàn)閟ource有了新值

// 最佳實(shí)踐：標(biāo)記移動(dòng)操作為noexcept
MyString(MyString&& other) noexcept {
    data = other.data;
    other.data = nullptr;
}

// 這樣STL容器在擴(kuò)容時(shí)會(huì)優(yōu)先使用移動(dòng)而不是復(fù)制
std::vector<MyString> vec;
vec.push_back(MyString("test"));  // 當(dāng)vector需要擴(kuò)容時(shí)會(huì)使用移動(dòng)操作

// 對(duì)于int、double這樣的簡(jiǎn)單類(lèi)型，移動(dòng)和復(fù)制沒(méi)有區(qū)別
int a = 5;
int b = std::move(a);  // 和 int b = a; 效果完全一樣
std::cout << a;  // 輸出仍然是5，因?yàn)閕nt的移動(dòng)就是復(fù)制

class OnlyCopy {
public:
    OnlyCopy(const OnlyCopy& other) { /*...*/ }  // 只定義了復(fù)制構(gòu)造
    // 編譯器不會(huì)生成移動(dòng)構(gòu)造和移動(dòng)賦值
};

class OnlyMove {
public:
    OnlyMove(OnlyMove&& other) noexcept { /*...*/ }  // 只定義了移動(dòng)構(gòu)造
    // 編譯器不會(huì)生成復(fù)制構(gòu)造和復(fù)制賦值
};

// 創(chuàng)建一個(gè)字符串向量并添加數(shù)據(jù)
std::vector<MyString> names;
for(int i = 0; i < 1000; ++i) {
    names.push_back(MyString("很長(zhǎng)的字符串..."));  // 每次可能導(dǎo)致擴(kuò)容
}

// 返回一個(gè)包含百萬(wàn)個(gè)元素的向量
std::vector<int> createLargeVector() {
    std::vector<int> result;
    for(int i = 0; i < 1000000; ++i) {
        result.push_back(i);
    }
    return result;  // 返回一個(gè)巨大的對(duì)象！
}

// 使用這個(gè)函數(shù)
void useVector() {
    std::vector<int> myVec = createLargeVector();  // 不用擔(dān)心性能了！
}

// 交換兩個(gè)很大的字符串
MyString a("超長(zhǎng)字符串...");
MyString b("另一個(gè)超長(zhǎng)字符串...");

// C++98的交換
void old_swap(MyString& a, MyString& b) {
    MyString temp(a);  // 復(fù)制構(gòu)造
    a = b;            // 復(fù)制賦值
    b = temp;         // 復(fù)制賦值
}

// C++11的交換
void new_swap(MyString& a, MyString& b) {
    MyString temp(std::move(a));  // 移動(dòng)構(gòu)造
    a = std::move(b);             // 移動(dòng)賦值
    b = std::move(temp);          // 移動(dòng)賦值
}

// unique_ptr的核心特點(diǎn)：獨(dú)占所有權(quán)，不允許復(fù)制
std::unique_ptr<BigObject> p1(new BigObject());
// std::unique_ptr<BigObject> p2 = p1;  // 錯(cuò)誤！不能復(fù)制

// 但有了移動(dòng)語(yǔ)義，我們可以轉(zhuǎn)移所有權(quán)：
std::unique_ptr<BigObject> p2 = std::move(p1);  // 成功！p1變?yōu)榭?，p2獲得所有權(quán)

std::unique_ptr<BigObject> createObject() {
    auto ptr = std::make_unique<BigObject>();
    // 配置對(duì)象...
    return ptr;  // 自動(dòng)使用移動(dòng)語(yǔ)義，資源所有權(quán)被轉(zhuǎn)移
}

void processObject() {
    auto obj = createObject();  // obj獲得所有權(quán)
    // 使用obj...
}  // obj自動(dòng)釋放資源

// std::move簡(jiǎn)化版實(shí)現(xiàn)（揭開(kāi)它的神秘面紗）
template<typename T>
typename std::remove_reference<T>::type&& move(T&& param) {
    return static_cast<typename std::remove_reference<T>::type&&>(param);
}

// 偽代碼，更容易理解
template<typename T>
右值引用類(lèi)型 move(參數(shù)) {
    return 把參數(shù)轉(zhuǎn)成右值引用類(lèi)型;
}

MyString a("Hello");  // a是個(gè)普通的左值

// std::move在這里施了個(gè)魔法！
MyString b = std::move(a);  // 把a(bǔ)貼上"可以偷我"的標(biāo)簽

#include <iostream>
#include <string>
usingnamespacestd;

int main() {
    string name = "Hello World";  // name是個(gè)左值
    
    cout << "原始name: " << name << endl;
    
    // 錯(cuò)誤理解：下面這行會(huì)移動(dòng)name
    string new_name = std::move(name);
    
    // 真相：std::move只是轉(zhuǎn)換類(lèi)型，真正的移動(dòng)發(fā)生在string的移動(dòng)構(gòu)造函數(shù)中
    cout << "移動(dòng)后name: " << name << endl;  // name可能為空或未定義狀態(tài)
    cout << "new_name: " << new_name << endl;
}

原始name: Hello World
移動(dòng)后name: 
new_name: Hello World

vector<int> v1 = {1, 3, 5};
auto v2 = std::move(v1);  // v1被轉(zhuǎn)換成右值引用
// cout << v1[0] << endl;  // 危險(xiǎn)！v1的狀態(tài)未定義
v1 = {1, 2, 3};  // 重新賦值后才能安全使用

// 不要這樣做
vector<int> createVector() {
    vector<int> result = {1, 2, 3};
    return std::move(result);  // 多余的！編譯器已經(jīng)會(huì)自動(dòng)應(yīng)用返回值優(yōu)化
}

// 正確做法
vector<int> createVector() {
    vector<int> result = {1, 2, 3};
    return result;  // 編譯器會(huì)自動(dòng)處理
}

// 場(chǎng)景1：當(dāng)你確定不再需要某個(gè)變量時(shí)
string str = "hello";
doSomething(std::move(str));  // str的值被移走了

// 場(chǎng)景2：實(shí)現(xiàn)移動(dòng)語(yǔ)義
void swap(T& a, T& b) {
    T temp = std::move(a);  // 移動(dòng)a到temp
    a = std::move(b);       // 移動(dòng)b到a
    b = std::move(temp);    // 移動(dòng)temp到b
}

// 場(chǎng)景3：將對(duì)象插入容器
vector<MyObject> v;
MyObject obj;
v.push_back(std::move(obj));  // 避免不必要的復(fù)制

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

int main() {
    constint NUM_STRINGS = 100000;  // 測(cè)試字符串?dāng)?shù)量
    constint STRING_SIZE = 1000;      // 每個(gè)字符串大小

    // 創(chuàng)建源數(shù)據(jù) - 兩個(gè)相同的字符串向量
    std::vector<std::string> sourceDataCopy;
    std::vector<std::string> sourceDataMove;

    // 填充源數(shù)據(jù)
    for (int i = 0; i < NUM_STRINGS; i++) {
        sourceDataCopy.push_back(std::string(STRING_SIZE, 'x'));
        sourceDataMove.push_back(std::string(STRING_SIZE, 'x'));
    }

    // 準(zhǔn)備目標(biāo)容器
    std::vector<std::string> destCopy;
    std::vector<std::string> destMove;
    destCopy.reserve(NUM_STRINGS);
    destMove.reserve(NUM_STRINGS);

    // 測(cè)試復(fù)制性能
    auto startCopy = std::chrono::high_resolution_clock::now();

    for (constauto& str : sourceDataCopy) {
        destCopy.push_back(str);  // 復(fù)制插入
    }

    auto endCopy = std::chrono::high_resolution_clock::now();

    // 測(cè)試移動(dòng)性能
    auto startMove = std::chrono::high_resolution_clock::now();

    for (auto& str : sourceDataMove) {
        destMove.push_back(std::move(str));  // 移動(dòng)插入
    }

    auto endMove = std::chrono::high_resolution_clock::now();

    // 計(jì)算時(shí)間
    auto copyTime = std::chrono::duration_cast<std::chrono::milliseconds>(endCopy - startCopy).count();
    auto moveTime = std::chrono::duration_cast<std::chrono::milliseconds>(endMove - startMove).count();

    // 輸出結(jié)果
    std::cout << "插入" << NUM_STRINGS << "個(gè)字符串(每個(gè)"
        << STRING_SIZE << "字符)的時(shí)間對(duì)比:\n";
    std::cout << "復(fù)制方式: " << copyTime << " ms\n";
    std::cout << "移動(dòng)方式: " << moveTime << " ms\n";
    std::cout << "性能比率: 復(fù)制/移動(dòng) = "
        << (moveTime > 0 ? static_cast<double>(copyTime) / moveTime : 0)
        << " 倍\n";

    // 驗(yàn)證移動(dòng)確實(shí)發(fā)生了
    size_t emptyCount = 0;
    for (constauto& str : sourceDataMove) {
        if (str.empty()) emptyCount++;
    }
    std::cout << "被移動(dòng)的源字符串?dāng)?shù)量: " << emptyCount << " (應(yīng)該接近于 " << NUM_STRINGS << ")\n";

    return0;
}

插入100000個(gè)字符串(每個(gè)1000字符)的時(shí)間對(duì)比:
復(fù)制方式: 170 ms
移動(dòng)方式: 68 ms
性能比率: 復(fù)制/移動(dòng) = 2.5 倍
被移動(dòng)的源字符串?dāng)?shù)量: 100000 (應(yīng)該接近于 100000)

std::string name = "一個(gè)很長(zhǎng)的字符串...";
std::string name2;

// 當(dāng)你確定之后不再使用name的值時(shí)
name2 = std::move(name);  // 直接偷走name的資源

// 此后不應(yīng)該再訪(fǎng)問(wèn)name的值，除非重新賦值
// cout << name << endl;  // 危險(xiǎn)！name可能已被掏空
name = "新值";  // 這樣是安全的

std::vector<int> createVector() {
    std::vector<int> result;
    // 填充result...
    
    return result;  // 不需要std::move！
    // 編譯器會(huì)自動(dòng)優(yōu)化，可能直接在調(diào)用者空間構(gòu)造，
    // 或者應(yīng)用移動(dòng)語(yǔ)義
}

std::vector<int> createVector() {
    std::vector<int> result;
    // ...
    return std::move(result);  // 錯(cuò)誤用法！可能阻礙RVO
}

class Buffer {
private:
    char* data;
    size_t size;

public:
    // 移動(dòng)構(gòu)造函數(shù)
    Buffer(Buffer&& other) noexcept
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
    
    // 移動(dòng)賦值運(yùn)算符
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
    
    // ... 其他成員 ...
};

std::vector<MyLargeObject> collection;

MyLargeObject obj = createLargeObject();  // 創(chuàng)建一個(gè)大對(duì)象

// 不好的方式：復(fù)制obj到容器
collection.push_back(obj);  // obj會(huì)被復(fù)制

// 更好的方式：移動(dòng)obj到容器
collection.push_back(std::move(obj));  // obj被移動(dòng)，避免復(fù)制
// 此后obj處于有效但未指定狀態(tài)

template <typename T>
void my_swap(T& a, T& b) {
    T temp = std::move(a);  // 移動(dòng)a到temp
    a = std::move(b);       // 移動(dòng)b到a
    b = std::move(temp);    // 移動(dòng)temp到b
}

void processAndStore(std::string&& str) {
    // 因?yàn)閰?shù)是右值引用，我們知道調(diào)用者不再需要它
    storage.push_back(std::move(str));  // 可以安全地移動(dòng)
}

// 調(diào)用方式
processAndStore(std::string("臨時(shí)字符串"));  // 直接傳遞臨時(shí)對(duì)象
std::string s = "hello";
processAndStore(std::move(s));  // 明確表示不再需要s的值

std::string name = "Alice";
std::string greeting = "Hello, " + std::move(name);  // 錯(cuò)誤用法！
std::cout << "Name: " << name << std::endl;  // name的值現(xiàn)在不確定

// 不需要這樣做
return std::move(result);  // 多余的！編譯器會(huì)自動(dòng)處理返回值優(yōu)化(RVO)

int a = 5;
int b = std::move(a);  // 沒(méi)有效果，和 int b = a; 完全一樣

std::vector<int> createVector() {
    std::vector<int> result;
    // 填充result...
    return result;  // 編譯器通常會(huì)自動(dòng)應(yīng)用移動(dòng)語(yǔ)義或返回值優(yōu)化
}

std::string s = std::string("hello") + " world";  // 右側(cè)臨時(shí)對(duì)象會(huì)被移動(dòng)，而非復(fù)制

class MyClass {
public:
    MyClass() { std::cout << "構(gòu)造\n"; }
    MyClass(const MyClass&) { std::cout << "復(fù)制構(gòu)造\n"; }
    MyClass(MyClass&&) noexcept { std::cout << "移動(dòng)構(gòu)造\n"; }
    // ...
};

int main() {
    MyClass a;
    MyClass b = a;           // 輸出"復(fù)制構(gòu)造"
    MyClass c = std::move(a); // 輸出"移動(dòng)構(gòu)造"
}

string original = "Hello World";
string new_str = std::move(original);

// original現(xiàn)在可能是空的！除非你給它新值，否則別再用它

int a = 5;
int b = std::move(a);  // 沒(méi)意義，和 int b = a; 完全一樣

MyClass(MyClass&& other) noexcept {
    data = other.data;       // 偷資源
    other.data = nullptr;    // 記得標(biāo)記原對(duì)象"已被偷" 
}