C++ Socket庫網絡編程設計模式

在C++中，使用Socket庫進行網絡編程時，可以采用多種設計模式來提高代碼的可讀性、可維護性和可擴展性。以下是一些常見的設計模式及其在網絡編程中的應用：

1. 單例模式（Singleton Pattern）

單例模式確保一個類只有一個實例，并提供一個全局訪問點。這在創建和管理網絡連接時非常有用。

class NetworkConnection {
private:
    static NetworkConnection* instance_;
    std::socket_t socket_;

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

    // 禁止復制和賦值
    NetworkConnection(const NetworkConnection&) = delete;
    NetworkConnection& operator=(const NetworkConnection&) = delete;

    void connect(const std::string& host, int port) {
        // 連接邏輯
    }

    // 其他網絡操作方法
};

2. 工廠模式（Factory Pattern）

工廠模式用于創建對象，而不需要指定具體的類。這在處理不同類型的網絡連接時非常有用。

class ConnectionFactory {
public:
    virtual ~ConnectionFactory() = default;

    virtual std::unique_ptr<NetworkConnection> createConnection(const std::string& host, int port) = 0;
};

class TCPConnectionFactory : public ConnectionFactory {
public:
    std::unique_ptr<NetworkConnection> createConnection(const std::string& host, int port) override {
        return std::make_unique<TCPNetworkConnection>(host, port);
    }
};

class UDPConnectionFactory : public ConnectionFactory {
public:
    std::unique_ptr<NetworkConnection> createConnection(const std::string& host, int port) override {
        return std::make_unique<UDPNetworkConnection>(host, port);
    }
};

3. 觀察者模式（Observer Pattern）

觀察者模式定義了一種一對多的依賴關系，讓多個觀察者對象同時監聽某一個主題對象。當主題對象狀態發生改變時，它的所有依賴者（觀察者）都會自動收到通知并更新。

class NetworkConnection : public Observer {
private:
    std::socket_t socket_;
    // 其他網絡連接相關的數據

public:
    void connect(const std::string& host, int port) {
        // 連接邏輯
        // 連接成功后，通知所有觀察者
        notifyObservers();
    }

    // 其他網絡操作方法

    void addObserver(Observer* observer) {
        observers_.push_back(observer);
    }

    void removeObserver(Observer* observer) {
        observers_.erase(std::remove(observers_.begin(), observers_.end(), observer), observers_.end());
    }

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

    // Observer接口方法
    void update() override {
        // 處理連接狀態變化
    }

private:
    std::vector<Observer*> observers_;
};

4. 策略模式（Strategy Pattern）

策略模式定義了一系列的算法，把它們一個個封裝起來，并且使它們可以相互替換。這在處理不同的網絡協議時非常有用。

class NetworkStrategy {
public:
    virtual ~NetworkStrategy() = default;

    virtual void sendData(const std::string& data) = 0;
    virtual std::string receiveData() = 0;
};

class TCPStrategy : public NetworkStrategy {
public:
    void sendData(const std::string& data) override {
        // TCP發送數據邏輯
    }

    std::string receiveData() override {
        // TCP接收數據邏輯
    }
};

class UDPStrategy : public NetworkStrategy {
public:
    void sendData(const std::string& data) override {
        // UDP發送數據邏輯
    }

    std::string receiveData() override {
        // UDP接收數據邏輯
    }
};

5. 代理模式（Proxy Pattern）

代理模式為其他對象提供一個代理以控制對這個對象的訪問。這在需要控制網絡連接的訪問時非常有用。

class NetworkConnectionProxy {
private:
    NetworkConnection* connection_;

public:
    NetworkConnectionProxy(NetworkConnection* connection) : connection_(connection) {}

    void connect(const std::string& host, int port) {
        connection_->connect(host, port);
    }

    void sendData(const std::string& data) {
        connection_->sendData(data);
    }

    std::string receiveData() {
        return connection_->receiveData();
    }

    // 其他代理方法
};

這些設計模式可以幫助你更好地組織和管理網絡編程代碼，提高代碼的可讀性和可維護性。根據具體的需求和場景，可以選擇合適的設計模式來解決問題。