一个花括号引发的性能灾难：C++17 前后的惊人对比

// C++17之前的故事
auto shopping = {1, 2, 3};    // 购物清单？不，是 std::initializer_list<int>
auto score{95};               // 考试分数？不，依然是 std::initializer_list<int>

int x{42};          // 直接类型，得到 int
auto x{42};         // C++17前：意外得到 std::initializer_list<int>

// 开发者的直觉预期
int a = 42;        // 得到一个整数
int b{42};         // 同样得到一个整数
auto c = 42;       // 应该也是一个整数
auto d{42};        // 按理说也应该是一个整数

// C++17之前的实际情况
// 前三个符合预期
// 但是最后一个令人惊讶：
auto d{42};        // 意外得到 std::initializer_list<int>！

void performance_example() {
    auto val1{42};      // C++17前：创建不必要的 initializer_list
    int val2{42};       // 直接构造，没有额外开销
    
    // 在频繁调用的代码中，这种差异会带来性能影响
}

template<typename T>
void process(T value) {
    auto copy{value};   // C++17前：如果T是int，这里会意外创建initializer_list
}

// C++17的明智选择
auto age{25};                 // 终于！就是普通的 int 啦！
auto price{19.99};           // 老老实实的 double

// 🎨 类型推导示例
auto name{"小明"};          // const char* - 字符串字面量
auto score{98.5};          // double - 浮点数
auto count{42};            // int - 整数
auto flag{true};          // bool - 布尔值

// ⚠️ 注意这些情况
autolist = {1,2,3};      // std::initializer_list<int> - 使用等号会创建列表
// auto error{1,2,3};     // ❌ 编译错误 - 直接花括号不能包含多个值

// 🔄 在循环中的应用
for(auto i{0}; i < 5; ++i) {  // 更清晰的循环计数器类型
    // ... 
}

// 💡 与智能指针配合使用
auto ptr{std::make_unique<int>(42)};  // 清晰的智能指针类型推导

// 🆕 C++17 新语法
auto value{42};              // ✅ int
auto price{99.9};           // ✅ double
auto name{"张三"};          // ✅ const char*

// 👴 保持传统行为的语法
auto items = {1, 2, 3};     // 📝 std::initializer_list<int>
auto prices = {10.5, 20.8}; // 📝 std::initializer_list<double>

// ⚠️ 以下代码无法通过编译
// auto error{1, 2, 3};     // ❌ 直接使用花括号不能包含多个值
// auto mix{1, 2.0};        // ❌ 不同类型值也不行

// 💡 实用技巧：在函数模板中特别有用
template<typename T>
void process(T value) {
    auto copy{value};       // ✨ 现在会正确推导类型，而不是变成initializer_list
}

#include <vector>
#include <string>

// 📦 定义商品结构
struct Product {
    std::string name;    // 商品名称
    double price;        // 商品价格
};

// 🛒 购物车演示
void shoppingDemo() {
    // ✨ C++17新特性: 单值花括号初始化
    auto item{"手机"};        // 🎯 直接推导为 const char*
    auto price{4999.99};     // 💰 直接推导为 double
    
    // ❌ 错误示范
    auto cart{1, 2, 3};      // 🚫 编译错误：花括号内不能有多个值
    
    // ✅ 正确的列表初始化方式
    auto wishList = {1, 2, 3};  // 📝 明确使用 std::initializer_list<int>
    
    // 🎁 创建实际的商品对象
    Product phone{"智能手机", 4999.99};  // 使用花括号初始化结构体
}

// 内存模型对比示例
void memoryModelDemo() {
    // 1️⃣ int 的内存模型
    auto simple{42};    // 直接在栈上分配4字节
                       // [42] - 仅存储值本身
    
    // 2️⃣ initializer_list 的内存模型
    autocomplex = {42};  // 包含两个部分：
                         // 1. 指向数组的指针 (4/8字节)
                         // 2. 数组长度信息 (4/8字节)
                         // 3. 实际数据存储在别处
    
    // 📊 内存占用演示
    struct MemoryLayout {
        static void showSize() {
            auto val{42};
            auto lst = {42};
            
            std::cout << "int 占用: " << sizeof(val) << " 字节\n"
                     << "initializer_list 占用: " << sizeof(lst) << " 字节\n";
        }
    };
}

// 🎯 实际应用场景
class DataContainer {
    int direct_value{42};              // ✅ 高效的单值存储
    std::initializer_list<int> list;   // ⚠️ 注意：list只是个视图，
                                      // 底层数组可能已经被销毁
    
public:
    // 展示生命周期问题
    void demonstrateLifetime() {
        auto temp = {1, 2, 3};        // 临时列表
        list = temp;                   // ⚠️ 危险：temp离开作用域后
                                      // list将变成悬空引用
    }
};

// 💫 返回值示例

// ❌ 错误示例：不能使用花括号初始化作为返回值
auto getDiscount() {
    return {0.8};  // 编译错误：auto 无法推导花括号初始化的返回类型
}

// ✅ 正确示例：直接返回值
auto getDiscount() {
    return0.8;    // 正确：明确返回 double 类型
}

// 🎯 更多实用示例
auto calculateValues() {
    // return {1, 2, 3};     // ❌ 错误：不能直接返回花括号初始化列表
    returnstd::vector{1, 2, 3};  // ✅ 正确：明确指定容器类型
}

// 💡 如果确实需要返回初始化列表，需要明确指定返回类型
std::initializer_list<int> getList() {
    return {1, 2, 3};  // ✅ 正确：返回类型已明确指定
}

#include <map>
#include <vector>

void containerDemo() {
    // 🗺️ 映射容器的优雅初始化
    auto prices = std::map{
        std::pair{"苹果", 5.5},    // 键值对自动推导
        std::pair{"香蕉", 3.5}     // 无需显式指定类型
    };  // ✨ 自动推导为 map<const char*, double>

    // 📦 向量容器的简洁初始化
    auto numbers = std::vector{
        1, 2, 3, 4, 5// 🎯 元素类型自动推导
    };  // 推导为 vector<int>

    // 🔄 嵌套容器的初始化
    auto matrix = std::vector{
        std::vector{1, 2, 3},  // 二维向量
        std::vector{4, 5, 6}   // 自动推导所有层级的类型
    };  // 推导为 vector<vector<int>>
    
    // 🎨 自定义类型的容器
    struct Point {int x, y; };
    auto points = std::vector{
        Point{1, 2},    // 结构体初始化更简洁
        Point{3, 4}     // 不需要显式构造函数调用
    };  // 推导为 vector<Point>
}