在C++中，文件操作流的設計模式通常涉及以下幾個方面：

1. 單例模式（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;
   

2. 工廠模式（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 {
       // 文本文件流實現
   };
   

3. 觀察者模式（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 {
           // 處理寫入操作
       }
   };
   

4. 策略模式（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++中的文件操作流，提高代碼的可維護性和可擴展性。