#include <vector>
#include <iostream>
// 這里會(huì)觸發(fā) std::vector 的拷貝構(gòu)造函數(shù)
void modify(std::vector<int> v) { 
    v.push_back(999);
    std::cout << "modify內(nèi)vector的長(zhǎng)度為: " << v.size() << std::endl;
    // 函數(shù)結(jié)束，局部變量 v 被銷毀，999 也隨之消失
    // 外部的 list 毫發(fā)無(wú)損
}
int main() {
    // 假設(shè)這是一個(gè)包含 100 萬(wàn)個(gè)元素的列表
    std::vector<int> bigList(1000000, 1);
    // 調(diào)用時(shí)發(fā)生 Deep Copy，性能開(kāi)銷極大
    modify(bigList); 
    std::cout << "main函數(shù)內(nèi)vector的長(zhǎng)度為: " << bigList.size() << std::endl;
    return 0;
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
    // Java 總是按值傳遞，但對(duì)于對(duì)象，傳遞的是“引用的值”
    public static void modify(List<Integer> v) {
        v.add(999);
        System.out.println("modify內(nèi)List的長(zhǎng)度為: " + v.size());
    }
    public static void main(String[] args) {
        // 創(chuàng)建包含 100 萬(wàn)個(gè)元素的列表
        List<Integer> bigList = new ArrayList<>(Collections.nCopies(1000000, 1));
        // 這里傳遞的是引用，沒(méi)有深拷貝，性能開(kāi)銷極小
        modify(bigList);
        // 注意：這里的長(zhǎng)度會(huì)變成 1000001
        System.out.println("main中List的長(zhǎng)度為: " + bigList.size());
    }
}

#include <vector>
#include <iostream>
// 引用傳遞
void modify(std::vector<int>& v) { 
    v.push_back(999);
    // 直接操作內(nèi)存中的同一份數(shù)據(jù)
    std::cout << "modify內(nèi)vector的長(zhǎng)度為: " << v.size() << std::endl;
}
int main() {
    std::vector<int> bigList(1000000, 1);
    modify(bigList); 
    std::cout << "main函數(shù)內(nèi)vector的長(zhǎng)度為: " << bigList.size() << std::endl;
    return 0;
}

#include <vector>
#include <iostream>
// 指針傳遞
void modify(std::vector<int>* v) { 
    // 判斷是否為空，防止 Crash
    if (v != nullptr) {
        // 語(yǔ)法變化：用 '->' 來(lái)訪問(wèn)成員
        v->push_back(999); 
        std::cout << "modify內(nèi)vector的長(zhǎng)度為: " << v->size() << std::endl;
    }
}
int main() {
    std::vector<int> bigList(1000000, 1);
    // 調(diào)用變化：必須顯式取出地址 (&) 傳進(jìn)去
    modify(&bigList); 
    std::cout << "main函數(shù)內(nèi)vector的長(zhǎng)度為: " << bigList.size() << std::endl;
    return 0;
}

#include <iostream>
class Enemy {
public:
    Enemy() { std::cout << "Enemy Created" << std::endl; }
    ~Enemy() { std::cout << "Enemy Destroyed" << std::endl; }
    void attack() { std::cout << "Enemy attacks!" << std::endl; }
};
// 工廠函數(shù)：在堆上創(chuàng)建一個(gè)對(duì)象，并返回指針
Enemy* createEnemy() {
    // 危險(xiǎn)的源頭：new 出來(lái)的內(nèi)存，必須有人 delete
    return new Enemy(); 
}
void gameLogic() {
    // 獲取指針
    Enemy* boss = createEnemy();
    boss->attack();
    // 假設(shè)這里有一段復(fù)雜的邏輯
    if (true) {
        std::cout << "Player died, game over early." << std::endl;
        // 致命問(wèn)題：函數(shù)直接返回了，但 boss 指向的內(nèi)存沒(méi)釋放！
        return; 
    }
    // 只有代碼走到這里，內(nèi)存才會(huì)被釋放
    delete boss; 
}

#include <iostream>
class Enemy {
public:
    Enemy() { std::cout << "Enemy Created" << std::endl; }
    ~Enemy() { std::cout << "Enemy Destroyed" << std::endl; }
    void attack() { std::cout << "Enemy attacks!" << std::endl; }
};
// 工廠函數(shù)：在堆上創(chuàng)建一個(gè)對(duì)象，并返回指針
Enemy* createEnemy() {
    // 危險(xiǎn)的源頭：new 出來(lái)的內(nèi)存，必須有人 delete
    return new Enemy(); 
}
class EnemyWrapper {
private:
    // 持有原始指針
    Enemy* ptr;
public:
    // 【構(gòu)造函數(shù)】：獲取資源
    EnemyWrapper() {
        ptr = new Enemy(); 
    }
    // 【析構(gòu)函數(shù)】：釋放資源 (這是 RAII 的靈魂)
    ~EnemyWrapper() {
        if (ptr != nullptr) {
            delete ptr; // 只要 Wrapper 被銷毀，ptr 指向的內(nèi)存必被釋放
            std::cout << "Wrapper triggered delete!" << std::endl;
        }
    }
    // 模擬指針操作
    void attack() { ptr->attack(); }
};
void gameLogicSafe() {
    // 這是一個(gè)棧對(duì)象
    EnemyWrapper boss; 
    boss.attack();
    if (true) {
        std::cout << "Game over early." << std::endl;
        // 即使這里 return，棧變量 boss 也會(huì)彈出
        return;
        // 編譯器自動(dòng)插入代碼：call boss.~EnemyWrapper() -> delete ptr
    }
}
int main() {
    gameLogicSafe();
    return 0;
}

Enemy* getBoss() {
    // 棧對(duì)象
    EnemyWrapper wrapper; 
    // 極其危險(xiǎn)！
    return wrapper.ptr;   
} // 函數(shù)結(jié)束 -> wrapper 析構(gòu) -> wrapper.ptr 被 delete
void main() {
    Enemy* p = getBoss(); 
    // 崩潰！p 指向的內(nèi)存已經(jīng)被 wrapper 刪掉了（懸空指針）
    p->attack(); 
}

#include <iostream>
// 模擬一個(gè)“昂貴”的資源
class Enemy {
public:
    Enemy() { std::cout << "  [堆資源] Enemy 被 new 出來(lái)了 (耗時(shí)操作...)" << std::endl; }
    ~Enemy() { std::cout << "  [堆資源] Enemy 被 delete 掉了" << std::endl; }
};
// RAII 包裝類
class EnemyWrapper {
private:
    Enemy* ptr;
public:
    // 【構(gòu)造函數(shù)】：獲取資源
    EnemyWrapper() {
        std::cout << "[Wrapper] 普通構(gòu)造" << std::endl;
        ptr = new Enemy(); 
    }
    // 【析構(gòu)函數(shù)】：釋放資源
    ~EnemyWrapper() {
        if (ptr != nullptr) {
            delete ptr;
            std::cout << "[Wrapper] 析構(gòu)，釋放資源" << std::endl;
        }
    }
    // ==========================================
    // 【拷貝構(gòu)造函數(shù)】(Deep Copy) -> 性能瓶頸在這里！
    // ==========================================
    // 當(dāng)我們需要復(fù)制這個(gè)對(duì)象時(shí)（比如函數(shù)返回），必須調(diào)用這個(gè)函數(shù)
    EnemyWrapper(const EnemyWrapper& other) {
        std::cout << "[Wrapper] ?? 觸發(fā)深拷貝！必須分配新內(nèi)存..." << std::endl;
        // 笨重的深拷貝：
        // A. 必須 new 一個(gè)新的 Enemy (不能共用指針，否則會(huì) double free)
        ptr = new Enemy(); 
        // B. (如果有數(shù)據(jù)) 還要把 other.ptr 里的數(shù)據(jù)復(fù)制過(guò)來(lái)
        // *ptr = *(other.ptr); 
    }
};
// 觸發(fā)拷貝的函數(shù)
EnemyWrapper createBoss() {
    std::cout << "--- 進(jìn)入函數(shù) ---" << std::endl;
    // Step 1: temp 創(chuàng)建，new Enemy (地址 A)
    EnemyWrapper temp; 
    std::cout << "--- 準(zhǔn)備返回 ---" << std::endl;
    // Step 2: return 時(shí)，因?yàn)橐獋髦到o外面，必須【拷貝】temp
    // 這意味著：調(diào)用拷貝構(gòu)造函數(shù) -> new Enemy (地址 B) -> 復(fù)制數(shù)據(jù)
    return temp; 
    // Step 3: 函數(shù)結(jié)束，temp 離開(kāi)作用域，delete A
    // (結(jié)果：我們?yōu)榱说玫?B，申請(qǐng)了 A，復(fù)制給 B，然后刪了 A。A 只是個(gè)中間商。)
}
int main() {
    std::cout << "=== 演示開(kāi)始 ===" << std::endl;
    EnemyWrapper boss = createBoss();
    std::cout << "=== 演示結(jié)束 ===" << std::endl;
    return 0;
}

int a = 10; 

EnemyWrapper getBoss() {
    // 返回一個(gè)新創(chuàng)建的對(duì)象
    return EnemyWrapper();
}
void main() {
    EnemyWrapper boss = getBoss(); 
}

// a 是左值，活得好好的
EnemyWrapper a; 
// 強(qiáng)行把 a 標(biāo)記為右值
EnemyWrapper b = std::move(a); 

#include <iostream>
// 模擬一個(gè)“昂貴”的資源
class Enemy {
public:
    Enemy() { std::cout << "  [堆資源] Enemy 被 new 出來(lái)了 (耗時(shí)操作...)" << std::endl; }
    ~Enemy() { std::cout << "  [堆資源] Enemy 被 delete 掉了" << std::endl; }
};
// RAII 包裝類
class EnemyWrapper {
private:
    Enemy* ptr;
public:
    // 【構(gòu)造函數(shù)】：獲取資源
    EnemyWrapper() {
        std::cout << "[Wrapper] 普通構(gòu)造" << std::endl;
        ptr = new Enemy(); 
    }
    // 【析構(gòu)函數(shù)】：釋放資源
    ~EnemyWrapper() {
        if (ptr != nullptr) {
            delete ptr;
            std::cout << "[Wrapper] 析構(gòu)，釋放資源" << std::endl;
        }
    }
    // ==========================================
    // 【拷貝構(gòu)造函數(shù)】(Deep Copy) -> 性能瓶頸在這里！
    // ==========================================
    // 當(dāng)我們需要復(fù)制這個(gè)對(duì)象時(shí)（比如函數(shù)返回），必須調(diào)用這個(gè)函數(shù)
    EnemyWrapper(const EnemyWrapper& other) {
        std::cout << "[Wrapper] ?? 觸發(fā)深拷貝！必須分配新內(nèi)存..." << std::endl;
        // 笨重的深拷貝：
        // A. 必須 new 一個(gè)新的 Enemy (不能共用指針，否則會(huì) double free)
        ptr = new Enemy(); 
        // B. (如果有數(shù)據(jù)) 還要把 other.ptr 里的數(shù)據(jù)復(fù)制過(guò)來(lái)
        // *ptr = *(other.ptr); 
    }
    // 【移動(dòng)構(gòu)造】(Move) - C++11 的新方案
    // 參數(shù)是 &&，表示對(duì)方是“將死之物”
    EnemyWrapper(EnemyWrapper&& other) noexcept {
        // 1. 偷梁換柱：把對(duì)方的指針拿過(guò)來(lái)
        this->ptr = other.ptr;
        // 2. 毀滅證據(jù)：把對(duì)方的指針設(shè)為 nullptr
        // 這一步至關(guān)重要！
        // 當(dāng) other 析構(gòu)時(shí)，它會(huì) delete nullptr (什么也不做)
        // 從而避免了資源被誤刪
        other.ptr = nullptr; 
        std::cout << "Move: Ownership transferred!" << std::endl;
    }
};
// 觸發(fā)移動(dòng)構(gòu)造函數(shù)
EnemyWrapper createBoss() {
    // 這一行代碼做了兩件事：
    // 1. 在【棧】上分配了 EnemyWrapper 這個(gè)殼子的內(nèi)存（非?？欤恍枰?new）
    // 2. 自動(dòng)調(diào)用了它的構(gòu)造函數(shù)
    EnemyWrapper temp; 
    // temp 是局部變量，返回時(shí)被視為右值
    return temp; 
}
int main() {
    // 1. createBoss 返回臨時(shí)對(duì)象（右值）
    // 2. 觸發(fā)【移動(dòng)構(gòu)造函數(shù)】
    // 3. main 里的 boss 直接接管了 temp 里的指針
    // 4. temp 變成空殼被銷毀
    EnemyWrapper boss = createBoss(); 
    // 結(jié)果：
    // - 沒(méi)有發(fā)生 Deep Copy (省了 new/copy)
    // - 沒(méi)有傳遞裸指針 (全程都在 RAII 包裝下，非常安全)
}

// 假設(shè)這是“魔改版”的拷貝構(gòu)造函數(shù) (沒(méi)有 const)
EnemyWrapper(EnemyWrapper& other) {
    this->ptr = other.ptr;
    other.ptr = nullptr; // 偷偷把原件毀了！
}
void logicalDisaster() {
    EnemyWrapper a; // a 有資源
    // 我只想做一個(gè)備份
    EnemyWrapper b = a; 
    // 災(zāi)難發(fā)生：a 變成空殼了！
    // 后面的代碼如果繼續(xù)用 a，程序直接崩潰。
    a.attack(); // Crash!
}

EnemyWrapper createBoss() {
    EnemyWrapper temp; 
    // 正確寫法：編譯器會(huì)自動(dòng)優(yōu)化 (RVO)
    // 編譯器會(huì)直接在外部變量的內(nèi)存地址上構(gòu)造 temp，連“移動(dòng)”都不需要做！
    // 成本 = 0
    return temp; 
    // 錯(cuò)誤寫法：畫蛇添足
    // return std::move(temp); 
    // 這會(huì)強(qiáng)行打斷編譯器的 RVO 優(yōu)化，強(qiáng)制執(zhí)行一次“移動(dòng)構(gòu)造”。
    // 成本 > 0 (雖然也很低，但是屬于“負(fù)優(yōu)化”)
}

int main() {
    // 1. RVO 自動(dòng)優(yōu)化，這里沒(méi)有拷貝，也沒(méi)有移動(dòng)
    EnemyWrapper boss1 = createBoss(); 
    // 2. 假設(shè)你想把 boss1 轉(zhuǎn)給 boss2
    // EnemyWrapper boss2 = boss1; // 編譯報(bào)錯(cuò)（假設(shè)禁用了拷貝）或深拷貝（慢）
    // 3. 這里必須用 std::move！
    // 因?yàn)?boss1 是個(gè)活著的左值，編譯器不敢自動(dòng)動(dòng)它。
    // 你必須手動(dòng)簽署“放棄所有權(quán)書”。
    EnemyWrapper boss2 = std::move(boss1); 
    // 此刻：boss2 拿到了指針，boss1 變成了空殼。
}

EnemyWrapper(EnemyWrapper&& other) noexcept {
    // 1. 接過(guò)房產(chǎn)證
    this->ptr = other.ptr; 
    // 2. 原主注銷，從此這房子和你無(wú)關(guān)了
    other.ptr = nullptr; 
}

#include <iostream>
#include <memory> // 必須包含這個(gè)頭文件
// 模擬一個(gè)“昂貴”的資源
class Enemy {
public:
    Enemy() { std::cout << "  [堆資源] Enemy 被 new 出來(lái)了 (耗時(shí)操作...)" << std::endl; }
    ~Enemy() { std::cout << "  [堆資源] Enemy 被 delete 掉了" << std::endl; }
    void attack() { std::cout << "Enemy attacks!" << std::endl; }
};
void uniqueDemo() {
    // 1. 創(chuàng)建 (推薦用 make_unique，不要直接 new)
    std::unique_ptr<Enemy> boss = std::make_unique<Enemy>(); 
    boss->attack(); // 用起來(lái)像指針
    // 2. 禁止拷貝！
    // std::unique_ptr<Enemy> boss2 = boss; // ? 編譯報(bào)錯(cuò)！
    // 3. 可以移動(dòng)！
    // 這里的 move 就像我們?cè)?Part 2 學(xué)的那樣，把所有權(quán)轉(zhuǎn)給 p2
    std::unique_ptr<Enemy> boss2 = std::move(boss); 
    // 此時(shí)：
    // boss 變成了 nullptr (空)
    // boss2 擁有了對(duì)象
} // 函數(shù)結(jié)束 -> boss2 析構(gòu) -> 自動(dòng) delete Enemy
int main() {
    uniqueDemo();
    return 0;
}

#include <iostream>
#include <memory> // 必須包含這個(gè)頭文件
// 模擬一個(gè)“昂貴”的資源
class Enemy {
public:
    Enemy() { std::cout << "  [堆資源] Enemy 被 new 出來(lái)了 (耗時(shí)操作...)" << std::endl; }
    ~Enemy() { std::cout << "  [堆資源] Enemy 被 delete 掉了" << std::endl; }
    void attack() { std::cout << "Enemy attacks!" << std::endl; }
};
void sharedDemo() {
    // 1. 創(chuàng)建 (引用計(jì)數(shù) = 1)
    std::shared_ptr<Enemy> p1 = std::make_shared<Enemy>();
    {
        // 2. 拷貝 (引用計(jì)數(shù) = 2)
        // 注意：這里是可以直接 "=" 賦值的，因?yàn)樗枪蚕淼?
        std::shared_ptr<Enemy> p2 = p1; 
        p2->attack();
        std::cout << "當(dāng)前引用數(shù): " << p1.use_count() << std::endl; // 輸出 2
    } 
    // p2 離開(kāi)作用域，引用計(jì)數(shù) -1 (變回 1)。對(duì)象還活著！
    p1->attack(); 
} // 函數(shù)結(jié)束，p1 離開(kāi)，引用計(jì)數(shù) -1 (變成 0) -> delete Enemy
int main() {
    sharedDemo();
    return 0;
}

#include <iostream>
#include <memory>
// 前置聲明：因?yàn)?A 里面要用 B，B 里面要用 A，必須先告訴編譯器 B 是個(gè)類
class B; 
class A {
public:
    // A 持有 B 的強(qiáng)引用 (shared_ptr)
    std::shared_ptr<B> ptrB; 
    A() { std::cout << "A Created (構(gòu)造)" << std::endl; }
    ~A() { std::cout << "A Destroyed (析構(gòu)) <--- 如果看到這句話，說(shuō)明沒(méi)泄露" << std::endl; }
};
class B {
public:
    // B 持有 A 的強(qiáng)引用 (shared_ptr) -> 導(dǎo)致死鎖
    std::shared_ptr<A> ptrA; 
    B() { std::cout << "B Created (構(gòu)造)" << std::endl; }
    ~B() { std::cout << "B Destroyed (析構(gòu)) <--- 如果看到這句話，說(shuō)明沒(méi)泄露" << std::endl; }
};
int main() {
    std::cout << "=== 進(jìn)入作用域 ===" << std::endl;
    {
        // 1. 創(chuàng)建對(duì)象
        // 此時(shí) A 的計(jì)數(shù) = 1 (只有變量 a 指向它)
        // 此時(shí) B 的計(jì)數(shù) = 1 (只有變量 b 指向它)
        std::shared_ptr<A> a = std::make_shared<A>();
        std::shared_ptr<B> b = std::make_shared<B>();
        std::cout << "1. 初始引用計(jì)數(shù):" << std::endl;
        std::cout << "   A counts: " << a.use_count() << std::endl;
        std::cout << "   B counts: " << b.use_count() << std::endl;
        // 2. 建立循環(huán)引用 (互相鎖死)
        std::cout << "2. 建立循環(huán)引用 (a->ptrB = b; b->ptrA = a;)" << std::endl;
        a->ptrB = b; // B 的計(jì)數(shù) +1 -> 變成 2 (b 變量 + a.ptrB)
        b->ptrA = a; // A 的計(jì)數(shù) +1 -> 變成 2 (a 變量 + b.ptrA)
        std::cout << "   A counts: " << a.use_count() << std::endl;
        std::cout << "   B counts: " << b.use_count() << std::endl;
        std::cout << "--- 準(zhǔn)備離開(kāi)作用域 ---" << std::endl;
    } // 3. 這里！離開(kāi)作用域！
    // 正常邏輯：
    // - 棧變量 a 銷毀 -> A 計(jì)數(shù)減 1 (2 -> 1) -> 不為 0，A 不死！
    // - 棧變量 b 銷毀 -> B 計(jì)數(shù)減 1 (2 -> 1) -> 不為 0，B 不死！
    // 結(jié)果：A 拿著 B，B 拿著 A，誰(shuí)也撒不開(kāi)手。堆內(nèi)存永遠(yuǎn)無(wú)法釋放。
    std::cout << "=== 離開(kāi)作用域 (main 結(jié)束) ===" << std::endl;
    std::cout << "警告：你沒(méi)有看到析構(gòu)函數(shù)的日志，說(shuō)明發(fā)生了內(nèi)存泄漏！" << std::endl;
    return 0;
}

#include <iostream>
#include <memory>
class B; // 前置聲明
class A {
public:
    // A 持有 B 的【強(qiáng)引用】(shared_ptr)
    // 意味著：只要 A 活著，B 就不能死
    std::shared_ptr<B> ptrB; 
    A() { std::cout << "A Created (構(gòu)造)" << std::endl; }
    ~A() { std::cout << "A Destroyed (析構(gòu))" << std::endl; }
};
class B {
public:
    // 關(guān)鍵修改：B 持有 A 的【弱引用】(weak_ptr)
    // 意味著：B 只是看著 A，但 B 不決定 A 的生死。
    // weak_ptr 不會(huì)增加 shared_ptr 的引用計(jì)數(shù)！
    std::weak_ptr<A> ptrA; 
    B() { std::cout << "B Created (構(gòu)造)" << std::endl; }
    ~B() { std::cout << "B Destroyed (析構(gòu))" << std::endl; }
};
int main() {
    std::cout << "=== 進(jìn)入作用域 ===" << std::endl;
    {
        // 1. 創(chuàng)建對(duì)象
        std::shared_ptr<A> a = std::make_shared<A>();
        std::shared_ptr<B> b = std::make_shared<B>();
        // 2. 建立引用
        std::cout << "--- 建立連接 ---" << std::endl;
        a->ptrB = b; // A 強(qiáng)引用 B。B 的計(jì)數(shù) = 2 (main里的b + A里的ptrB)
        b->ptrA = a; // B 弱引用 A。A 的計(jì)數(shù) = 1 (只有main里的a) !!!
        std::cout << "當(dāng)前引用計(jì)數(shù) (關(guān)鍵點(diǎn)):" << std::endl;
        // A 的計(jì)數(shù)只有 1，因?yàn)?weak_ptr 不算數(shù)
        std::cout << "   A counts: " << a.use_count() << " (只有 main 持有它)" << std::endl; 
        // B 的計(jì)數(shù)是 2，因?yàn)?A 強(qiáng)引用著它
        std::cout << "   B counts: " << b.use_count() << " (main 和 A 都持有它)" << std::endl;
        std::cout << "--- 準(zhǔn)備離開(kāi)作用域 ---" << std::endl;
    } 
    // 3. 離開(kāi)作用域的過(guò)程：
    // Step 1: 變量 'a' 銷毀。
    //    A 的引用計(jì)數(shù)從 1 變成 0。
    //    -> A 死了！打印 "A Destroyed"。
    //    -> A 析構(gòu)時(shí)，會(huì)自動(dòng)銷毀它的成員 ptrB。
    // Step 2: A 的成員 ptrB 被銷毀。
    //    B 的引用計(jì)數(shù)從 2 減為 1。
    // Step 3: 變量 'b' 銷毀。
    //    B 的引用計(jì)數(shù)從 1 變成 0。
    //    -> B 死了！打印 "B Destroyed"。
    std::cout << "=== 離開(kāi)作用域 (main 結(jié)束) ===" << std::endl;
    return 0;
}