C++文件操作流的设计模式

在C++中，文件操作流的设计模式通常涉及以下几个方面：

单例模式（Singleton Pattern）：

目的：确保文件操作流对象在整个程序中只创建一个实例，避免重复创建和资源浪费。
实现：通过私有化构造函数，提供一个静态方法来获取唯一的实例。

class FileStream {
private:
    static FileStream* instance_;
    FileStream() {}

public:
    static FileStream* getInstance() {
        if (!instance_) {
            instance_ = new FileStream();
        }
        return instance_;
    }

    void write(const std::string& data) {
        // 写入文件操作
    }

    std::string read() {
        // 读取文件操作
        return "";
    }
};

FileStream* FileStream::instance_ = nullptr;

工厂模式（Factory Pattern）：

目的：提供创建文件操作流对象的接口，隐藏具体的实现细节。
实现：通过工厂类来创建不同类型的文件操作流对象。

class FileStreamFactory {
public:
    static std::unique_ptr<FileStream> createFileStream(const std::string& type) {
        if (type == "binary") {
            return std::make_unique<BinaryFileStream>();
        } else if (type == "text") {
            return std::make_unique<TextFileStream>();
        }
        return nullptr;
    }
};

class BinaryFileStream : public FileStream {
    // 二进制文件流实现
};

class TextFileStream : public FileStream {
    // 文本文件流实现
};

观察者模式（Observer Pattern）：

目的：当文件操作状态发生变化时，通知所有感兴趣的观察者。
实现：通过定义一个主题接口和一个观察者接口，实现对象间的解耦。

class FileStreamSubject {
private:
    std::vector<std::shared_ptr<FileStreamObserver>> observers_;

public:
    void addObserver(std::shared_ptr<FileStreamObserver> observer) {
        observers_.push_back(observer);
    }

    void removeObserver(std::shared_ptr<FileStreamObserver> observer) {
        observers_.erase(std::remove(observers_.begin(), observers_.end(), observer), observers_.end());
    }

    void notifyObservers() {
        for (auto& observer : observers_) {
            observer->update();
        }
    }

    void write(const std::string& data) {
        // 写入文件操作
        notifyObservers();
    }
};

class FileStreamObserver {
public:
    virtual void update() = 0;
};

class FileWriter : public FileStreamObserver {
public:
    void update() override {
        // 处理写入操作
    }
};

策略模式（Strategy Pattern）：

目的：定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。
实现：通过定义一个策略接口和多个具体策略类，实现算法的多态调用。

class FileWriteStrategy {
public:
    virtual void write(std::ostream& os, const std::string& data) = 0;
};

class BinaryWriteStrategy : public FileWriteStrategy {
public:
    void write(std::ostream& os, const std::string& data) override {
        // 二进制写入操作
    }
};

class TextWriteStrategy : public FileWriteStrategy {
public:
    void write(std::ostream& os, const std::string& data) override {
        // 文本写入操作
    }
};

class FileStream {
private:
    std::unique_ptr<FileWriteStrategy> writeStrategy_;

public:
    FileStream(std::unique_ptr<FileWriteStrategy> strategy) : writeStrategy_(strategy) {}

    void write(const std::string& data) {
        writeStrategy_->write(std::cout, data);
    }
};

int main() {
    auto binaryStrategy = std::make_unique<BinaryWriteStrategy>();
    FileStream fileStream(binaryStrategy);
    fileStream.write("Hello, World!");

    auto textStrategy = std::make_unique<TextWriteStrategy>();
    FileStream textFileStream(textStrategy);
    textFileStream.write("Hello, World!");

    return 0;
}

这些设计模式可以帮助你更好地组织和管理C++中的文件操作流，提高代码的可维护性和可扩展性。

最新问答

相关标签