桥接模式（附C++代码示例）_c++ 桥接模式

桥接模式的含义

桥接模式（Bridge Pattern）是一种结构型设计模式，用于将抽象部分与其实现部分分离，使它们可以独立地变化。通过这种方式，桥接模式提供了更好的代码组织结构，可以减少类之间的继承关系，并提供更灵活的设计以应对变化。

核心思想及解释

桥接模式的核心思想是分离抽象和实现，使得二者可以独立地变化。在这种模式中，抽象部分指的是有高层的控制逻辑，而实现部分则是底层的具体操作。桥接模式通过提供一个桥接结构，使得抽象层和实现层不直接交互，而是通过桥接接口来进行通信，从而实现解耦。

为什么要使用桥接模式

1. 改善可扩展性： 当抽象和实现可以独立变化时，增加新的实现或抽象变得更容易。
2. 避免固定绑定： 最初设计时不需要预见所有可能的变化，新增功能只需扩展实现部分。
3. 减少类的数量： 桥接模式可以帮助折叠多维度的继承结构，减少系统中的类的数量。

使用桥接模式需要注意的点

1. 理解设计的复杂性： 引入桥接模式会增加系统的设计复杂性，应当在多维度变化的情况下使用，以避免过度设计。
2. 抽象和实现的适当分离： 需要仔细设计抽象部分和实现部分的界限，确保两者的独立性。

工程的应用场景

1. 当一个系统需要在多个维度上变化，或者它需要独立于其实现的不同部分时： 如不同的用户界面和业务逻辑的组合。
2. 避免类的爆炸性增长： 特别是在有多种变化因素时，桥接模式可以有效管理这种复杂性。
3. 分享实现： 允许多个对象共享一个实现，而不需关心外界如何使用它。

示例代码及解释

假设有一个设备控制系统，有不同类型的设备（如电视和收音机）和多种遥控器类型。使用桥接模式，我们可以独立地处理遥控器和设备的变化。

定义设备接口（实现部分）和具体设备：

#include <iostream>

// Implementor
class Device {
public:
    virtual bool isEnabled() = 0;
    virtual void enable() = 0;
    virtual void disable() = 0;
    virtual ~Device() {}
};

// Concrete Implementor 1
class TV : public Device {
    bool on = false;
public:
    bool isEnabled() override {
        return on;
    }

    void enable() override {
        on = true;
        std::cout << "TV is turned on.\n";
    }

    void disable() override {
        on = false;
        std::cout << "TV is turned off.\n";
    }
};

// Concrete Implementor 2
class Radio : public Device {
    bool on = false;
public:
    bool isEnabled() override {
        return on;
    }

    void enable() override {
        on = true;
        std::cout << "Radio is turned on.\n";
    }

    void disable() override {
        on = false;
        std::cout << "Radio is turned off.\n";
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

定义抽象和扩展抽象：

// Abstraction
class RemoteControl {
protected:
    Device* device;
public:
    RemoteControl(Device* d) : device(d) {}
    virtual void togglePower() {
        if (device->isEnabled()) {
            device->disable();
        } else {
            device->enable();
        }
    }
    virtual ~RemoteControl() {}
};

// Refined Abstraction
class AdvancedRemoteControl : public RemoteControl {
public:
    AdvancedRemoteControl(Device* d) : RemoteControl(d) {}
    void mute() {
        std::cout << "Device is muted.\n";
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

客户端代码：

int main() {
    Device* tv = new TV();
    RemoteControl* remote = new RemoteControl(tv);
    remote->togglePower(); // Turns TV on

    Device* radio = new Radio();
    AdvancedRemoteControl* advancedRemote = new AdvancedRemoteControl(radio);
    advancedRemote->togglePower(); // Turns Radio on
    advancedRemote->mute(); // Mute the radio

    delete tv;
    delete radio;
    delete remote;
    delete advancedRemote;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出代码运行结果

TV is turned on.
Radio is turned on.
Device is muted.
1
2
3

这个示例展示了如何使用桥接模式分离设备类型和遥控器的功能，使得对遥控器或设备类型的任何修改都不会影响到彼此。这种方式提高了代码的可维护性和扩展性。