c++设计模式之桥接模式

桥接模式（Bridge Pattern）是一种结构型设计模式，目的是将抽象部分与其实现部分解耦，使得它们可以独立地变化。桥接模式适合用于那些在不同的操作系统或平台间切换时，可以保持接口一致，同时又能灵活扩展功能的场景。在您的监控软件中，桥接模式可以帮助将监控逻辑和交换机的具体实现解耦。

桥接模式的核心思想

桥接模式的核心思想是通过组合的方式，将抽象和实现分离。这样我们可以独立地修改抽象部分和实现部分。您可以将监控软件的核心逻辑（抽象）和具体交换机型号的命令（实现）分开，通过桥接实现它们之间的联系。
桥接模式在交换机监控中的应用

在您的场景中，监控软件（如配置、查询等功能）是抽象部分，具体的交换机（S5730、S12700等）是实现部分。通过桥接模式，您可以让监控软件与交换机的具体命令完全解耦，这样当要支持新的交换机时，只需实现新的交换机模块，而无需改动监控软件的核心逻辑。
桥接模式的组件

Abstraction（抽象角色）：这是定义客户请求的接口，通常会保存一个对实现部分的引用。它不直接实现功能，而是通过调用实现部分的接口来完成任务。

RefinedAbstraction（扩展抽象角色）：继承自 Abstraction，扩展了更多的功能。

Implementor（实现角色）：这是实现接口的核心部分，它定义了功能的具体实现方法。

ConcreteImplementor（具体实现角色）：实现 Implementor 接口，提供具体功能的实现。
示例代码

4.1 定义桥接模式接口

cpp 复制代码

cpp
复制代码
// SwitchImplementor.h
#ifndef SWITCH_IMPLEMENTOR_H
#define SWITCH_IMPLEMENTOR_H

#include <string>

class SwitchImplementor {
public:
    virtual bool login(const std::string& username, const std::string& password) = 0;
    virtual bool logout() = 0;
    virtual void configureInterface(const std::string& interfaceName, const std::string& config) = 0;
    virtual std::string queryInterfaceStatus(const std::string& interface) = 0;
    virtual ~SwitchImplementor() {}
};

#endif // SWITCH_IMPLEMENTOR_H
SwitchImplementor 是实现接口，定义了交换机操作的基本方法，如登录、接口配置、查询状态等。
4.2 实现具体交换机型号
cpp
复制代码
// S5730Switch.h
#ifndef S5730SWITCH_H
#define S5730SWITCH_H

#include "SwitchImplementor.h"
#include <iostream>

class S5730Switch : public SwitchImplementor {
public:
    bool login(const std::string& username, const std::string& password) override {
        std::cout << "S5730 login with username: " << username << std::endl;
        return true;
    }

    bool logout() override {
        std::cout << "S5730 logout" << std::endl;
        return true;
    }

    void configureInterface(const std::string& interfaceName, const std::string& config) override {
        std::cout << "Configuring interface " << interfaceName << " on S5730 with: " << config << std::endl;
    }

    std::string queryInterfaceStatus(const std::string& interface) override {
        return "S5730 interface status for " + interface;
    }
};

#endif // S5730SWITCH_H
S5730Switch 是具体的实现类，提供了 S5730 交换机的特定实现。
cpp
复制代码
// S12700Switch.h
#ifndef S12700SWITCH_H
#define S12700SWITCH_H

#include "SwitchImplementor.h"
#include <iostream>

class S12700Switch : public SwitchImplementor {
public:
    bool login(const std::string& username, const std::string& password) override {
        std::cout << "S12700 login with username: " << username << std::endl;
        return true;
    }

    bool logout() override {
        std::cout << "S12700 logout" << std::endl;
        return true;
    }

    void configureInterface(const std::string& interfaceName, const std::string& config) override {
        std::cout << "Configuring interface " << interfaceName << " on S12700 with: " << config << std::endl;
    }

    std::string queryInterfaceStatus(const std::string& interface) override {
        return "S12700 interface status for " + interface;
    }
};

#endif // S12700SWITCH_H
S12700Switch 是另一个具体的实现类，提供了 S12700 交换机的特定实现。
4.3 定义抽象类
cpp
复制代码
// SwitchManager.h
#ifndef SWITCH_MANAGER_H
#define SWITCH_MANAGER_H

#include "SwitchImplementor.h"
#include <string>

class SwitchManager {
protected:
    SwitchImplementor* switchImpl;  // 通过SwitchImplementor来调用具体实现

public:
    SwitchManager(SwitchImplementor* impl) : switchImpl(impl) {}

    virtual bool login(const std::string& username, const std::string& password) {
        return switchImpl->login(username, password);
    }

    virtual bool logout() {
        return switchImpl->logout();
    }

    virtual void configureInterface(const std::string& interfaceName, const std::string& config) {
        switchImpl->configureInterface(interfaceName, config);
    }

    virtual std::string queryInterfaceStatus(const std::string& interface) {
        return switchImpl->queryInterfaceStatus(interface);
    }

    virtual ~SwitchManager() {
        delete switchImpl;
    }
};

#endif // SWITCH_MANAGER_H
SwitchManager 是桥接模式中的 Abstraction，它定义了抽象的操作（如登录、配置接口、查询状态等），并通过 switchImpl（SwitchImplementor 的指针）来调用具体的实现。
4.4 扩展抽象类（可选）
cpp
复制代码
// AdvancedSwitchManager.h
#ifndef ADVANCED_SWITCH_MANAGER_H
#define ADVANCED_SWITCH_MANAGER_H

#include "SwitchManager.h"

class AdvancedSwitchManager : public SwitchManager {
public:
    AdvancedSwitchManager(SwitchImplementor* impl) : SwitchManager(impl) {}

    void advancedOperation() {
        std::cout << "Performing an advanced operation." << std::endl;
        // 其他特定的操作
    }
};

#endif // ADVANCED_SWITCH_MANAGER_H
AdvancedSwitchManager 是 RefinedAbstraction，它在 SwitchManager 的基础上可以添加更多的操作。
4.5 主程序示例
cpp
复制代码
// Main.cpp
#include "SwitchManager.h"
#include "S5730Switch.h"
#include "S12700Switch.h"
#include "AdvancedSwitchManager.h"
#include <iostream>

int main() {
    // 创建具体实现
    SwitchImplementor* s5730 = new S5730Switch();
    SwitchManager* manager = new SwitchManager(s5730);

    manager->login("admin", "password");
    manager->configureInterface("GigabitEthernet0/0/1", "description Test Interface");
    std::cout << manager->queryInterfaceStatus("GigabitEthernet0/0/1") << std::endl;
    manager->logout();

    delete manager;

    // 使用S12700交换机
    SwitchImplementor* s12700 = new S12700Switch();
    manager = new SwitchManager(s12700);

    manager->login("admin", "password");
    manager->configureInterface("GigabitEthernet0/0/1", "description Test Interface");
    std::cout << manager->queryInterfaceStatus("GigabitEthernet0/0/1") << std::endl;
    manager->logout();

    delete manager;

    return 0;
}

桥接模式工作流程
创建具体实现：首先创建具体交换机的实现类，如 S5730Switch 或 S12700Switch。
创建抽象类管理器：SwitchManager 作为抽象管理器，提供统一的接口。
通过桥接实现解耦：主程序通过 SwitchManager 与交换机进行交互，但不关心具体交换机的实现，只依赖于 SwitchImplementor 接口。
扩展功能：可以通过继承 SwitchManager 来扩展更多的高级功能，如 AdvancedSwitchManager。
优点
解耦：抽象与实现分离，主程序不关心具体交换机的实现，只通过统一接口与之交互。
灵活性：新增交换机型号时，只需实现一个新的 SwitchImplementor，无需修改 SwitchManager 或主程序。
可扩展性：可以通过扩展 SwitchManager 来增加更多的高级功能，而不影响已有的实现。
通过桥接模式，您可以很方便地将监控系统与交换机硬件进