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

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
    // Java 總是按值傳遞，但對于對象，傳遞的是“引用的值”
    public static void modify(List<Integer> v) {
        v.add(999);
        System.out.println("modify內(nèi)List的長度為: " + v.size());
    }
    public static void main(String[] args) {
        // 創(chuàng)建包含 100 萬個元素的列表
        List<Integer> bigList = new ArrayList<>(Collections.nCopies(1000000, 1));
        // 這里傳遞的是引用，沒有深拷貝，性能開銷極小
        modify(bigList);
        // 注意：這里的長度會變成 1000001
        System.out.println("main中List的長度為: " + 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的長度為: " << v.size() << std::endl;
}
int main() {
    std::vector<int> bigList(1000000, 1);
    modify(bigList); 
    std::cout << "main函數(shù)內(nèi)vector的長度為: " << bigList.size() << std::endl;
    return 0;
}

#include <vector>
#include <iostream>
// 指針傳遞
void modify(std::vector<int>* v) { 
    // 判斷是否為空，防止 Crash
    if (v != nullptr) {
        // 語法變化：用 '->' 來訪問成員
        v->push_back(999); 
        std::cout << "modify內(nèi)vector的長度為: " << v->size() << std::endl;
    }
}
int main() {
    std::vector<int> bigList(1000000, 1);
    // 調(diào)用變化：必須顯式取出地址 (&) 傳進去
    modify(&bigList); 
    std::cout << "main函數(shù)內(nèi)vector的長度為: " << 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)建一個對象，并返回指針
Enemy* createEnemy() {
    // 危險的源頭：new 出來的內(nèi)存，必須有人 delete
    return new Enemy(); 
}
void gameLogic() {
    // 獲取指針
    Enemy* boss = createEnemy();
    boss->attack();
    // 假設這里有一段復雜的邏輯
    if (true) {
        std::cout << "Player died, game over early." << std::endl;
        // 致命問題：函數(shù)直接返回了，但 boss 指向的內(nèi)存沒釋放！
        return; 
    }
    // 只有代碼走到這里，內(nèi)存才會被釋放
    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)建一個對象，并返回指針
Enemy* createEnemy() {
    // 危險的源頭：new 出來的內(nèi)存，必須有人 delete
    return new Enemy(); 
}
class EnemyWrapper {
private:
    // 持有原始指針
    Enemy* ptr;
public:
    // 【構造函數(shù)】：獲取資源
    EnemyWrapper() {
        ptr = new Enemy(); 
    }
    // 【析構函數(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() {
    // 這是一個棧對象
    EnemyWrapper boss; 
    boss.attack();
    if (true) {
        std::cout << "Game over early." << std::endl;
        // 即使這里 return，棧變量 boss 也會彈出
        return;
        // 編譯器自動插入代碼：call boss.~EnemyWrapper() -> delete ptr
    }
}
int main() {
    gameLogicSafe();
    return 0;
}

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

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

int a = 10; 

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

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

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

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

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

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

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

#include <iostream>
#include <memory> // 必須包含這個頭文件
// 模擬一個“昂貴”的資源
class Enemy {
public:
    Enemy() { std::cout << "  [堆資源] Enemy 被 new 出來了 (耗時操作...)" << 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(); // 用起來像指針
    // 2. 禁止拷貝！
    // std::unique_ptr<Enemy> boss2 = boss; // ? 編譯報錯！
    // 3. 可以移動！
    // 這里的 move 就像我們在 Part 2 學的那樣，把所有權轉(zhuǎn)給 p2
    std::unique_ptr<Enemy> boss2 = std::move(boss); 
    // 此時：
    // boss 變成了 nullptr (空)
    // boss2 擁有了對象
} // 函數(shù)結束 -> boss2 析構 -> 自動 delete Enemy
int main() {
    uniqueDemo();
    return 0;
}

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

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

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