别再写出会爆炸的代码了！这才是 C++ 引用的正确打开方式

class Story {
    string content_;    // 📚 存储故事的内容
public:
    // 🎬 构造新的故事
    Story(string text) : content_(text) {} 
    
    // 📖 安全地读取故事内容
    // 使用 const 修饰确保故事内容不会被修改 🔒
    string getContent() const { return content_; }
};

Story* createMagicStory() {
    // 🏗️ 在栈上创建一个临时的故事对象
    Story localStory{"从前有座山..."}; 
    
    // ⚠️ 危险操作!返回栈上对象的地址
    // 💥 函数返回后 localStory 会被销毁
    // 🚫 这将导致悬空指针
    return &localStory;                 
} // 💨 噗!localStory 已经消失在风中...

Story& getBestStory() {
    // 🏗️ 在栈上创建临时故事对象
    Story epicStory{"一个充满 bug 的世界..."};
    
    // ⚠️ 危险操作!返回临时对象的引用
    // 💨 函数结束时 epicStory 会被销毁
    // 👻 返回的引用将指向已经不存在的对象
    // 🚫 这会导致未定义行为
    return epicStory;    
} // 💥 轰!epicStory 已经消失,但引用还在死死地指向那片虚无

// 方式一：让故事安全地飞向远方 🚀
unique_ptr<Story> createSafeStory() {
    // 🏗️ 在堆上创建新的故事对象
    // 🔒 使用智能指针自动管理内存
    return make_unique<Story>("这是一个安全的故事~");
    
    // ✨ 函数结束时:
    // 📦 故事对象安全地存储在堆内存中
    // 🔑 unique_ptr 负责管理对象的生命周期
    // 🎯 直到最后一个使用者结束才会被销毁
} 

// 方式二：直接返回故事的副本 📝
Story getStoryDirectly() {
    // 📚 创建一个新的故事对象
    // 🔄 通过返回值优化(RVO)避免不必要的拷贝
    return Story{"一个值得传颂的故事"};
    
    // ✨ 函数结束时:
    // 📋 故事内容被安全复制
    // 🎁 调用者获得完整的故事副本
}

class AddressBook {
    vector<string> addresses_;  // 📚 存储所有居民的地址簿
public:
    // 🏠 安全地获取指定位置的地址引用
    // 📍 因为地址存储在地址簿的vector中,所以返回引用是安全的
    // 🔍 index: 要查找的地址索引
    // ⚡️ 返回: 对应地址的引用,可以直接修改
    string& getAddress(size_t index) {
        // 🛡️ 检查索引是否越界
        Expects(index < addresses_.size());
        
        // 📬 返回地址引用 - 就像在实体地址簿上直接修改地址一样
        return addresses_[index];
    }
};

void updateAddress(AddressBook& book) {
    // 📖 从地址簿中获取第一个地址的引用
    // 🔍 因为是引用,所以不会产生复制
    string& oldAddress = book.getAddress(0);      
    
    // ✏️ 直接修改地址内容
    // 📝 因为是引用,所以修改会直接影响原始数据
    // 🏠 更新为新的地址信息
    oldAddress = "新地址: 幸福小区88号";          
    
} // 📚 函数结束时地址簿保持更新后的状态
  // ✨ 因为我们修改的是原始数据,所以更改会永久保存

string& getTemporaryAddress() {
    // 🏠 在栈上创建临时地址字符串
    string addr = "临时地址";    
    
    // ⚠️ 危险操作!返回栈上临时变量的引用
    // 💥 函数返回后 addr 会被销毁
    // 👻 返回的引用将指向已释放的内存
    // 🚫 这会导致未定义行为
    return addr;               
    
} // 💨 噗!addr已经消失在风中...

class Thermometer {
    double current_temp_;    // 🌡️ 存储当前温度值
public:
    // 🔒 安全的温度读取方法
    // 📏 返回温度的常量引用,确保温度值不会被修改
    // ⚡️ 因为 current_temp_ 是类成员,所以返回其引用是安全的
    // 🎯 返回: 当前温度的只读引用
    const double& getCurrentTemp() const {
        return current_temp_;  // 🔍 只允许查看温度,不能修改
    }
    
    // 🔧 温度校准方法
    // 📐 返回温度的非常量引用,允许调整温度值
    // ⚙️ 用于校准或修正温度读数
    // 🎯 返回: 可修改的温度引用
    double& calibrateTemp() {
        return current_temp_;  // 🛠️ 可以调整温度值
    }
};

void checkTemperature() {
    Thermometer thermo;        // 🌡️ 创建一个温度计实例
    
    // 📊 获取当前温度的只读引用
    // ❄️ const引用确保温度值不会被意外修改
    constdouble& temp = thermo.getCurrentTemp();  
    
    // 🔧 获取可调整的温度引用
    // ⚙️ 用于校准温度值
    double& adjustable = thermo.calibrateTemp();   
    
    // 📈 对温度进行补偿调整
    // 🎯 直接修改原始温度值
    // 🔄 因为使用引用,所以修改会直接影响温度计中的实际值
    adjustable += 0.5;                            
} // ✨ 函数结束时温度计保持校准后的状态

// 🚨 危险示例:返回局部变量的指针
int* getHighScore() {
    // 🎮 在栈上创建局部变量
    int score = 100;  // 创造了新纪录!
    
    // 🎭 创建一个 lambda 表达式
    // ⚠️ 危险:通过引用捕获局部变量 score
    auto saveScore = [&]() { 
        return &score;  // 📌 返回局部变量的地址
    };
    
    // 💥 调用 lambda 并返回已经失效的指针
    // 🌫️ score 变量即将离开作用域被销毁
    return saveScore();  
    
} // 🪦 此时 score 已被销毁
// 👻 返回的指针变成了悬空指针

// ✅ 安全的做法:使用智能指针
shared_ptr<int> saveHighScoreSafely() {
    // 🏗️ 在堆上创建数据
    // 🔒 使用智能指针管理内存
    return make_shared<int>(100);
    
    // ✨ 函数结束时:
    // 📦 数据安全存储在堆上
    // 🔑 由 shared_ptr 管理生命周期
}

// 😱 危险示例:这是一个会导致未定义行为的代码!
class PetCollection {
    vector<string*> pets;  // 📌 存储指向字符串的指针(这是一个危险的设计)
public:
    void addPet() {
        // 🐱 在栈上创建临时字符串
        string kitty = "喵喵";       
        
        // ⚠️ 严重错误:存储了栈上临时变量的地址
        // 💥 当函数返回时,kitty 会被销毁
        // 👻 vector 中存储的指针将变成悬空指针
        pets.push_back(&kitty);     
        
    } // 🪦 到这里 kitty 已经被销毁了
      // 🌫️ pets 中的指针指向了已释放的内存
};

// ✅ 正确的实现方式:
class SafePetCollection {
    vector<string> pets;  // 🏠 直接存储字符串,而不是指针
public:
    void addPet() {
        // 🎈 创建新的字符串并存储其副本
        // 🔒 安全地将数据复制到 vector 中
        pets.push_back("喵喵");  
    }
};