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();
    }

    // 其他代理方法
};

这些设计模式可以帮助你更好地组织和管理网络编程代码，提高代码的可读性和可维护性。根据具体的需求和场景，可以选择合适的设计模式来解决问题。