C/C++基础知识复习（51）

1. ​如何处理对象的创建与销毁的时机？

通俗解释：

对象的创建和销毁就像租房和退房，需要明确时机，避免资源浪费。如果你借了房子，但没有及时归还，别人就无法使用它。同样，如果你创建了对象但没有及时销毁，可能会导致内存泄漏或资源浪费。

详细方法：

1. ​RAII（Resource Acquisition Is Initialization）​

RAII 是 C++ 的核心思想之一，它的核心原则是：

• ​资源获取即初始化：在构造函数中获取资源（如内存、文件句柄、锁等）。
• ​资源释放即析构：在析构函数中释放资源。

2. ​智能指针

智能指针是 C++ 提供的工具，用于自动管理动态分配的内存。它会在对象不再需要时自动释放资源，就像“自动退房”的机制。

RAII 示例：

#include 
#include 

class FileHandler {
private:
    std::ofstream file;

public:
    // 构造函数：获取资源（打开文件）
    FileHandler(const std::string& filename) {
        file.open(filename);
        if (file.is_open()) {
            std::cout << "File opened successfully.\n";
        } else {
            std::cout << "Failed to open file.\n";
        }
    }

    // 析构函数：释放资源（关闭文件）
    ~FileHandler() {
        if (file.is_open()) {
            file.close();
            std::cout << "File closed successfully.\n";
        }
    }

    void write(const std::string& data) {
        if (file.is_open()) {
            file << data;
        }
    }
};

int main() {
    {
        FileHandler file("example.txt"); // 创建对象，打开文件
        file.write("Hello, RAII!");     // 写入数据
    } // 超出作用域，自动调用析构函数，关闭文件
    return 0;
}

智能指针示例：

#include 
#include 

class MyClass {
public:
    MyClass() { std::cout << "Object created.\n"; }
    ~MyClass() { std::cout << "Object destroyed.\n"; }
    void doSomething() { std::cout << "Doing something.\n"; }
};

int main() {
    {
        std::unique_ptr ptr = std::make_unique(); // 创建对象
        ptr->doSomething(); // 使用对象
    } // 超出作用域，自动销毁对象
    return 0;
}

总结：

• ​RAII：通过构造函数获取资源，通过析构函数释放资源，确保资源管理的安全性。
• ​智能指针：自动管理动态分配的内存，避免内存泄漏。

---

2. ​C++中面向对象编程如何处理对象的状态存储与恢复？

通俗解释：

状态存储与恢复就像游戏存档和读档。你可以保存游戏的当前状态（存档），之后可以恢复到保存的状态（读档）。在编程中，对象的状态也可以保存和恢复。

详细方法：

使用 ​备忘录模式（Memento Pattern）​，将对象的状态保存到一个“备忘录”中，之后可以恢复。

备忘录模式的核心思想：

1. ​Originator：原始对象，负责创建备忘录和从备忘录恢复状态。
2. ​Memento：备忘录，保存对象的状态。
3. ​Caretaker：负责保存和管理备忘录。

代码示例：

#include 
#include 
#include 

// 备忘录类：保存对象的状态
class Memento {
private:
    std::string state;

public:
    Memento(const std::string& s) : state(s) {}
    std::string getState() const { return state; }
};

// 原始对象类
class Originator {
private:
    std::string state;

public:
    void setState(const std::string& s) {
        state = s;
        std::cout << "State set to: " << state << "\n";
    }

    // 创建备忘录
    std::shared_ptr createMemento() const {
        return std::make_shared(state);
    }

    // 从备忘录恢复状态
    void restoreMemento(const std::shared_ptr& memento) {
        state = memento->getState();
        std::cout << "State restored to: " << state << "\n";
    }
};

// 管理者类：负责保存备忘录
class Caretaker {
private:
    std::shared_ptr memento;

public:
    void saveMemento(const std::shared_ptr& m) {
        memento = m;
    }

    std::shared_ptr getMemento() const {
        return memento;
    }
};

int main() {
    Originator originator;
    Caretaker caretaker;

    // 设置初始状态
    originator.setState("State 1");

    // 保存状态
    caretaker.saveMemento(originator.createMemento());

    // 修改状态
    originator.setState("State 2");

    // 恢复状态
    originator.restoreMemento(caretaker.getMemento());

    return 0;
}

总结：

• ​备忘录模式：通过将对象的状态保存到备忘录中，实现状态的存储与恢复。
• ​适用场景：需要保存和恢复对象状态的场景，如撤销操作、游戏存档等。