// 基礎(chǔ)類型還算簡單 ?
int x = 42;                        
double pi = 3.14159;               

// 向量初始化 - 好痛苦！??
std::vector<int> v;                
v.push_back(1);                    // 一個接一個地添加...
v.push_back(2);                    // 寫得手都酸了
v.push_back(3);                    // 還沒完嗎？

// map 初始化 - 更麻煩了！??
std::map<std::string, int> scores; 
scores["張三"] = 95;               // 一個一個插入
scores["李四"] = 87;               // 繼續(xù)插入...

// 為什么只有數(shù)組可以這樣？??
int arr[] = {1, 2, 3};          

// 基礎(chǔ)類型變得更整潔了！ ?
int x{42};                         // 再見了，等號！

// 向量初始化變得超簡單！ ??
std::vector<int> v{1, 2, 3};      // 一行代碼搞定，清爽！

// map 也能輕松搞定！ ??
std::map<std::string, int> scores{
    {"張三", 95},                 // 鍵值對直觀明了
    {"李四", 87}                  // 再也不用 scores["xxx"] = yyy
};

// 結(jié)構(gòu)體也能優(yōu)雅初始化！ ??
struct Student {
    std::string name;
    int age;
    std::vector<std::string> hobbies;
};

// 看看這清晰的層次感！ ??
Student xiaoming{
    "小明",                       // 名字一目了然
    16,                           // 年齡清清楚楚
    {"編程", "打游戲", "看動漫"}  // 愛好一目了然，還支持嵌套！ ??
};

// 傳統(tǒng)初始化方式 - 危險的靜默轉(zhuǎn)換 ??
int x = 3.14;    // 糟糕!悄悄把 3.14 截斷成了 3
                 // 編譯器完全不會警告你 ??

// 列表初始化 - 嚴(yán)格的安全檢查 ??
int y{3.14};     // 編譯器立即報錯: "narrowing conversion" ?
                 // 防止你犯下可能導(dǎo)致數(shù)據(jù)丟失的錯誤 

// 更多安全檢查示例 ??
long long big{10000000000};  // OK ? - 數(shù)值在 long long 范圍內(nèi)
int small{big};             // 錯誤! ? - 可能的數(shù)據(jù)丟失
bool flag{5};               // 錯誤! ? - 不允許隱式轉(zhuǎn)換為布爾值

// 返回值也能用列表初始化，告別臨時變量！ ??
auto getMagicNumbers() {
    return std::vector<int>{1, 2, 3, 4, 5};  // 直接返回，簡潔優(yōu)雅 ?
}

// 使用 initializer_list 讓參數(shù)傳遞更靈活 ??
void printList(std::initializer_list<std::string> items) {
    for (const auto& item : items) {
        std::cout << item << "?";  // 給每個元素加點閃光 ?
    }
}

// 調(diào)用時簡單直觀，不需要先創(chuàng)建容器
printList({"蘋果", "香蕉", "橙子"});  // 水果清單一目了然 ??????

class WishList {
public:
    // 為你的類添加列表初始化支持 ??
    WishList(std::initializer_list<std::string> wishes) {
        // 在這里實現(xiàn)愿望清單的處理邏輯...
    }
};

// 創(chuàng)建對象時更加優(yōu)雅自然
WishList myWishes{
    "環(huán)游世界",   // 遠(yuǎn)大夢想 ??
    "學(xué)會跳舞",   // 生活情趣 ??
    "寫好代碼"    // 技能提升 ??
};

// 在 C++11 之前，不同容器有不同的初始化方式
std::vector<int> v1;          // 默認(rèn)構(gòu)造
std::vector<int> v2(3, 1);    // 構(gòu)造函數(shù)
v1.push_back(1);              // 單個添加元素

// 有了 initializer_list，所有容器都能統(tǒng)一使用 {} 語法
std::vector<int> v3{1, 2, 3}; // 優(yōu)雅！
std::list<int> l{1, 2, 3};    // 同樣的語法！
std::set<int> s{1, 2, 3};     // 到處都能用！

// 傳統(tǒng)方式處理可變數(shù)量參數(shù)很麻煩
void oldWay(int count, ...) {  // C風(fēng)格可變參數(shù)，類型不安全
    // 復(fù)雜的參數(shù)解析...
}

// 使用 initializer_list 優(yōu)雅處理
void newWay(std::initializer_list<int> nums) {  // 類型安全、使用簡單
    for (int num : nums) {
        // 處理每個參數(shù)...
    }
}

// 調(diào)用時非常直觀
newWay({1, 2, 3, 4, 5});  // 想傳幾個參數(shù)都可以

class MyContainer {
public:
    // 沒有 initializer_list 時，需要寫多個構(gòu)造函數(shù)
    MyContainer(int a) { /* ... */ }
    MyContainer(int a, int b) { /* ... */ }
    MyContainer(int a, int b, int c) { /* ... */ }  // 好煩！

    // 有了 initializer_list，一個構(gòu)造函數(shù)搞定所有情況
    MyContainer(std::initializer_list<int> values) {
        // 統(tǒng)一處理任意數(shù)量的初始值
    }
};

// 使用時非常靈活
MyContainer c1{1};         // OK
MyContainer c2{1, 2};      // OK
MyContainer c3{1, 2, 3};   // 還是 OK！

void processItems(std::initializer_list<int> items) {
    // items[0] = 42;  // ? 糟糕！不能修改元素
                       // initializer_list 就像一個保護(hù)罩，防止意外修改數(shù)據(jù)
    
    // ? 正確的使用方式：只讀遍歷
    for (const auto& item : items) {  
        std::cout << item << " ";  // 只能讀取，不能修改
    }
}

// ?? 內(nèi)部實現(xiàn)非常簡單，只需要兩個指針：
// - 一個指向數(shù)據(jù)的起始位置
// - 一個表示數(shù)據(jù)的長度
void example() {
    std::initializer_list<int> list = {1, 2, 3};  // 不會復(fù)制這些數(shù)字！
    
    // 提供了簡單但夠用的接口
    std::cout << "元素個數(shù): " << list.size() << std::endl;  // 獲取大小 ??
    
    // 支持迭代器操作 ??
    auto begin = list.begin();  // 開始位置
    auto end = list.end();      // 結(jié)束位置
}

class SmartContainer {
public:
    // ?? 普通構(gòu)造函數(shù) - 只接受一個大小參數(shù)
    SmartContainer(int size) { 
        std::cout << "調(diào)用普通構(gòu)造函數(shù)" << std::endl;
    }
    
    // ?? initializer_list 構(gòu)造函數(shù) - 可以接受任意數(shù)量的值
    SmartContainer(std::initializer_list<int> items) {
        std::cout << "調(diào)用 initializer_list 構(gòu)造函數(shù)" << std::endl;
    }
};

// 看看編譯器如何智能地選擇構(gòu)造函數(shù) ??
void demo() {
    SmartContainer c1(10);           // ?? 使用普通構(gòu)造函數(shù)
    SmartContainer c2{10};           // ?? 使用 initializer_list 構(gòu)造函數(shù)
    SmartContainer c3{1, 2, 3, 4};   // ?? 使用 initializer_list 構(gòu)造函數(shù)
}

// ?? 通用打印函數(shù)，可以處理任何類型的列表
template<typename T>
void printAll(std::initializer_list<T> items) {
    for (const auto& item : items) {
        std::cout << item << " ";  // ??? 逐個打印元素
    }
}

// ?? 看看它有多靈活！
printAll({1, 2, 3});           // ?? 處理數(shù)字
printAll({"貓", "狗", "兔"});   // ?? 處理字符串

class OptimizedContainer {
private:
    std::vector<int> data;
    
public:
    // ? 優(yōu)化的構(gòu)造函數(shù)
    OptimizedContainer(std::initializer_list<int> items) {
        data.reserve(items.size());  // ?? 提前分配空間，避免頻繁重新分配
        data = items;                // ?? 一次性復(fù)制所有數(shù)據(jù)
    }
};

void potential_problem() {
    // ? 這樣是安全的
    auto list = {1, 2, 3};  
    
    // ?? 危險操作！
    auto ptr = list.begin();
    // ? 不要在 initializer_list 銷毀后使用其迭代器
    // ?? ptr 可能指向已經(jīng)被釋放的內(nèi)存
}