C++设计模式（GOF-23）——05 C++桥模式（Bridge）（将抽象部分与实现部分分离，使它们可以独立变化。通过组合（聚合）方式替代继承，避免多维度变化导致的类爆炸问题）

桥接模式（Bridge Pattern）详解

桥接模式是一种结构型设计模式，其核心思想是将抽象部分与实现部分分离，使它们可以独立变化。通过组合（聚合）的方式替代继承，避免了多维度变化导致的类爆炸问题。

---

桥接模式的结构

桥接模式包含以下四个角色：

1. Abstraction（抽象化角色）：定义抽象接口，持有对实现化对象的引用。

2. RefinedAbstraction（扩展抽象化角色）：扩展抽象化角色的行为。

3. Implementor（实现化角色）：定义实现化接口，供抽象化角色调用。

4. ConcreteImplementor（具体实现化角色）：实现实现化接口的具体逻辑。

---

UML 图（Mermaid）

1

1

Abstraction

+Implementor* implementor

+virtual void Operation()

RefinedAbstraction

+void Operation()

Implementor

+virtual void OperationImpl()

ConcreteImplementorA

+void OperationImpl()

ConcreteImplementorB

+void OperationImpl()

---

C++ 实现示例

场景描述

假设我们要设计一个图形绘制系统，图形有不同的形状（圆形、矩形）和颜色（红色、蓝色）。如果不使用桥接模式，形状和颜色的组合会导致类爆炸（例如：红圆、蓝圆、红矩形、蓝矩形等）。使用桥接模式后，形状和颜色可以独立变化。

代码实现

#include 
#include 

// 1. 实现化角色（Implementor）
// 定义颜色接口（接口名称添加 "I" 前缀）
class IColor {
public:
    virtual void paint() = 0;
    virtual ~IColor() {}  // 虚析构函数确保子类析构正确
};

// 2. 具体实现化角色（ConcreteImplementor）
// 红色实现
class Red : public IColor {
public:
    void paint() override {
        std::cout << "Painting with red color." << std::endl;
    }
};

// 蓝色实现
class Blue : public IColor {
public:
    void paint() override {
        std::cout << "Painting with blue color." << std::endl;
    }
};

// 3. 抽象化角色（Abstraction）
// 定义图形接口（接口名称添加 "I" 前缀）
class IShape {
protected:
    std::shared_ptr<IColor> color;  // 使用智能指针管理资源
public:
    IShape(std::shared_ptr<IColor> color) : color(color) {}
    virtual void draw() = 0;
    virtual ~IShape() {}  // 虚析构函数确保子类析构正确
};

// 4. 扩展抽象化角色（RefinedAbstraction）
// 圆形实现
class Circle : public IShape {
public:
    Circle(std::shared_ptr<IColor> color) : IShape(color) {}
    void draw() override {
        std::cout << "Drawing a circle: ";
        color->paint();  // 委托给具体颜色实现
    }
};

// 矩形实现
class Rectangle : public IShape {
public:
    Rectangle(std::shared_ptr<IColor> color) : IShape(color) {}
    void draw() override {
        std::cout << "Drawing a rectangle: ";
        color->paint();  // 委托给具体颜色实现
    }
};

// 客户端代码
int main() {
    // 创建颜色对象
    auto red = std::make_shared<Red>();
    auto blue = std::make_shared<Blue>();

    // 创建图形对象并绑定颜色
    IShape* circleRed = new Circle(red);
    IShape* circleBlue = new Circle(blue);
    IShape* rectangleRed = new Rectangle(red);
    IShape* rectangleBlue = new Rectangle(blue);

    // 绘制图形
    circleRed->draw();      // 输出: Drawing a circle: Painting with red color.
    circleBlue->draw();     // 输出: Drawing a circle: Painting with blue color.
    rectangleRed->draw();   // 输出: Drawing a rectangle: Painting with red color.
    rectangleBlue->draw();  // 输出: Drawing a rectangle: Painting with blue color.

    // 释放资源
    delete circleRed;
    delete circleBlue;
    delete rectangleRed;
    delete rectangleBlue;

    return 0;
}

代码解释

1. IColor 接口

• 定义了颜色的基本操作 paint()，是实现化的抽象接口。
• 子类 Red 和 Blue 实现了具体的颜色逻辑。

2. IShape 接口

• 抽象化角色，持有颜色对象的指针（std::shared_ptr），通过组合的方式解耦形状和颜色。
• 子类 Circle 和 Rectangle 实现了具体的形状逻辑，并通过 color->paint() 调用颜色的实现。

3. 客户端代码

• 通过组合不同的形状和颜色，动态生成不同的图形（如红色圆形、蓝色矩形），无需为每种组合创建新类。
• 使用智能指针（std::shared_ptr）管理资源，避免内存泄漏。

---

UML 图（Mermaid）

uses shared_ptr

IColor

+virtual void paint()

+~IColor()

Red

+void paint()

Blue

+void paint()

IShape

#shared_ptr color

+virtual void draw()

+~IShape()

Circle

+void draw()

Rectangle

+void draw()

UML 图解释

代码

classDiagram
    class IColor {
        +virtual void paint() = 0
        +~IColor()
    }
    
    class Red {
        +void paint()
    }
    
    class Blue {
        +void paint()
    }
    
    class IShape {
        +virtual void draw() = 0
        +~IShape()
        #shared_ptr color
    }
    
    class Circle {
        +void draw()
    }
    
    class Rectangle {
        +void draw()
    }
    
    IColor <|-- Red
    IColor <|-- Blue
    
    IShape <|-- Circle
    IShape <|-- Rectangle
    
    IShape --> IColor : uses shared_ptr<IColor>

1. 类（Class）

• IColor: 抽象类，定义颜色接口。
• Red 和 Blue: IColor 的具体实现类。
• IShape: 抽象类，定义图形接口。
• Circle 和 Rectangle: IShape 的具体实现类。
• shared_ptr: 在 IShape 中作为成员变量，表示组合关系。

2. 关系符号

• <|--: 继承（泛化）。例如：
• IColor <|-- Red: Red 继承自 IColor。
• IShape <|-- Circle: Circle 继承自 IShape。
• -->: 关联（使用）。IShape 使用 IColor 的共享指针。
• #: 受保护的（protected）成员。IShape 中的 color 是受保护的。
• +: 公共的（public）成员。

3. 桥接模式的核心设计

- 抽象化（Abstraction）:

• IShape 是抽象类，持有 IColor 的共享指针。
• Circle 和 Rectangle 是扩展抽象化角色（RefinedAbstraction），实现 draw() 方法。

- 实现化（Implementor）:

• IColor 是接口，定义 paint() 方法。
• Red 和 Blue 是具体实现角色，实现颜色逻辑。

- 桥接（Bridge）:

• IShape 通过 shared_ptr 将颜色实现动态注入到图形中。

---

桥接模式的优点

1. 解耦抽象与实现

抽象和实现可以独立扩展，避免了继承导致的类爆炸。

2. 提高灵活性

运行时可以动态切换实现（例如，切换颜色或形状）。

3. 符合开闭原则

新增形状或颜色时，只需扩展对应的抽象或实现类，无需修改现有代码。

---

适用场景

1. 多维度变化的系统

例如，图形系统（形状 + 颜色）、设备控制（遥控器 + 电器）、跨平台 GUI（界面 + 操作系统 API）等。

2. 需要运行时切换实现

例如，动态切换渲染引擎、数据库驱动等。

---

总结

桥接模式通过组合替代继承，将抽象与实现分离，解决了多维度变化导致的复杂性问题。它适用于需要灵活扩展和解耦的场景，是设计模式中非常实用的结构型模式之一。