如何在C++中避免对象销毁以保留其信息供其他函数调用展示

嘿，很高兴帮你搞定这个问题！要让C++对象不被销毁、还能把它的信息传给另一个函数展示，其实有不少接地气的办法，我给你逐个拆解，附上手头的小例子：

1. 把对象放在更大的作用域里 #

这是最直观的思路——如果你的对象现在是某个子函数里的局部变量，那函数执行完它就会被自动销毁。那你可以把它移到外层作用域，比如main()函数里，或者一个模块级的全局位置（不过全局变量尽量少用，容易引发代码耦合问题）。

示例代码：

#include <iostream>
#include <string>

class UserInfo {
public:
    std::string name;
    int age;
    UserInfo(std::string n, int a) : name(n), age(a) {}
};

// 负责展示信息的函数
void showUserInfo(const UserInfo& user) {
    std::cout << "Name: " << user.name << ", Age: " << user.age << std::endl;
}

int main() {
    // 这个对象在main的作用域内，整个程序运行期间都存在
    UserInfo myUser("Alice", 25);
    
    // 直接把引用传给展示函数
    showUserInfo(myUser);
    
    // 后续其他函数也能继续访问myUser
    return 0;
}

优点：简单直接，完全不用操心内存管理；缺点：如果需要对象在多个独立模块间共享，可能会有作用域限制。

2. 使用静态对象 #

如果你必须在某个函数内部创建对象，但希望它一直存在，可以用static关键字修饰。静态局部对象的生命周期是从第一次被创建开始，直到整个程序结束。

示例代码：

#include <iostream>
#include <string>

class UserInfo {
public:
    std::string name;
    int age;
    UserInfo(std::string n, int a) : name(n), age(a) {}
};

UserInfo& getPersistentUser() {
    // 静态对象，第一次调用函数时创建，之后一直存在
    static UserInfo persistentUser("Bob", 30);
    return persistentUser;
}

void showUserInfo() {
    UserInfo& user = getPersistentUser();
    std::cout << "Name: " << user.name << ", Age: " << user.age << std::endl;
}

int main() {
    showUserInfo(); // 输出Bob的信息
    getPersistentUser().age = 31; // 修改对象属性
    showUserInfo(); // 输出更新后的年龄31
    return 0;
}

优点：不用手动管理内存，对象自动存活到程序结束；缺点：要注意线程安全（多线程下第一次创建可能出问题），而且静态对象是全局唯一的，不适合需要多个实例的场景。

3. 动态分配内存 + 智能指针 #

用new在堆上创建对象，这样对象不会随函数结束销毁——不过手动用new/delete容易忘释放导致内存泄漏，所以更推荐用智能指针（std::shared_ptr或std::unique_ptr）来自动管理内存。

比如用std::shared_ptr，它可以在多个地方共享对象的所有权，直到最后一个指针被销毁，对象才会被释放：

#include <iostream>
#include <string>
#include <memory>

class UserInfo {
public:
    std::string name;
    int age;
    UserInfo(std::string n, int a) : name(n), age(a) {}
    ~UserInfo() { std::cout << "UserInfo destroyed" << std::endl; }
};

void showUserInfo(const std::shared_ptr<UserInfo>& user) {
    std::cout << "Name: " << user->name << ", Age: " << user->age << std::endl;
}

int main() {
    // 创建一个共享指针管理堆上的对象
    std::shared_ptr<UserInfo> userPtr = std::make_shared<UserInfo>("Charlie", 28);
    
    // 传递给展示函数
    showUserInfo(userPtr);
    
    // 即使main函数结束，只要还有shared_ptr指向它，对象就不会销毁
    return 0;
}

优点：灵活，适合需要在多个函数/模块间传递对象的场景，自动管理内存；缺点：比局部对象多一点性能开销（不过大部分业务场景可以忽略）。

4. 单例模式（适合全局唯一对象） #

如果你的对象是整个程序唯一的实例，那单例模式是个不错的选择——它确保整个程序只有一个对象实例，并且一直存在。

这里给一个线程安全的简单单例实现：

#include <iostream>
#include <string>
#include <mutex>

class GlobalConfig {
private:
    std::string appName;
    static std::shared_ptr<GlobalConfig> instance;
    static std::mutex mtx;
    
    // 私有构造函数，禁止外部创建实例
    GlobalConfig() : appName("MyApp") {}
    
public:
    // 禁止拷贝和移动
    GlobalConfig(const GlobalConfig&) = delete;
    GlobalConfig& operator=(const GlobalConfig&) = delete;
    
    static std::shared_ptr<GlobalConfig> getInstance() {
        std::lock_guard<std::mutex> lock(mtx);
        if (!instance) {
            instance = std::shared_ptr<GlobalConfig>(new GlobalConfig());
        }
        return instance;
    }
    
    void setAppName(const std::string& name) { appName = name; }
    std::string getAppName() const { return appName; }
};

// 初始化静态成员
std::shared_ptr<GlobalConfig> GlobalConfig::instance = nullptr;
std::mutex GlobalConfig::mtx;

void showConfig() {
    auto config = GlobalConfig::getInstance();
    std::cout << "App Name: " << config->getAppName() << std::endl;
}

int main() {
    showConfig(); // 输出MyApp
    GlobalConfig::getInstance()->setAppName("NewApp");
    showConfig(); // 输出NewApp
    return 0;
}

优点：全局唯一，方便跨模块访问；缺点：增加了代码复杂度，单例对象难以进行单元测试，不适合需要多个实例的场景。

总结一下选方案的思路： #

• 如果你只是在几个函数间共享对象，优先考虑扩展作用域或者智能指针；
• 如果需要函数内创建的对象长期存在，用静态对象；
• 如果是全局唯一的配置类对象，用单例模式。

内容的提问来源于stack exchange，提问作者Fayssal Mahiaoui