编辑“︁C++ 桥接模式”︁

{{DISPLAYTITLE:C++桥接模式}}

'''桥接模式'''（Bridge Pattern）是[[设计模式]]中一种结构型模式，用于将抽象部分与其实现部分分离，使它们可以独立变化。该模式通过组合关系替代继承关系，从而减少类之间的耦合度，提高系统的灵活性。

== 概述 ==
桥接模式的核心思想是将一个对象的抽象（Abstraction）与实现（Implementation）解耦，使得两者可以独立地扩展。它适用于以下场景：
* 当一个类存在多个维度的变化时（例如形状和颜色）。
* 当需要避免多层继承导致类爆炸的问题时。
* 当需要在运行时切换实现时。

桥接模式包含以下主要角色：
* '''抽象类（Abstraction）'''：定义抽象接口，并包含一个对实现类的引用。
* '''扩展抽象类（Refined Abstraction）'''：扩展抽象类的接口。
* '''实现类接口（Implementor）'''：定义实现类的接口。
* '''具体实现类（Concrete Implementor）'''：实现实现类接口的具体类。

== 结构 ==
<mermaid>
classDiagram
    class Abstraction {
        +Implementor* implementor
        +operation()
    }
    class RefinedAbstraction {
        +operation()
    }
    interface Implementor {
        <<interface>>
        +operationImpl()
    }
    class ConcreteImplementorA {
        +operationImpl()
    }
    class ConcreteImplementorB {
        +operationImpl()
    }
    Abstraction <|-- RefinedAbstraction
    Abstraction o-- Implementor
    Implementor <|.. ConcreteImplementorA
    Implementor <|.. ConcreteImplementorB
</mermaid>

== 示例代码 ==
以下是一个桥接模式的C++实现示例，展示如何将形状（抽象）和颜色（实现）分离：

<syntaxhighlight lang="cpp">
#include <iostream>
#include <string>

// 实现类接口：颜色
class Color {
public:
    virtual ~Color() = default;
    virtual std::string getColor() const = 0;
};

// 具体实现类：红色
class Red : public Color {
public:
    std::string getColor() const override {
        return "Red";
    }
};

// 具体实现类：蓝色
class Blue : public Color {
public:
    std::string getColor() const override {
        return "Blue";
    }
};

// 抽象类：形状
class Shape {
protected:
    Color* color;
public:
    Shape(Color* color) : color(color) {}
    virtual ~Shape() = default;
    virtual void draw() const = 0;
};

// 扩展抽象类：圆形
class Circle : public Shape {
public:
    Circle(Color* color) : Shape(color) {}
    void draw() const override {
        std::cout << "Drawing a " << color->getColor() << " circle." << std::endl;
    }
};

// 扩展抽象类：方形
class Square : public Shape {
public:
    Square(Color* color) : Shape(color) {}
    void draw() const override {
        std::cout << "Drawing a " << color->getColor() << " square." << std::endl;
    }
};

int main() {
    Color* red = new Red();
    Color* blue = new Blue();

    Shape* redCircle = new Circle(red);
    Shape* blueSquare = new Square(blue);

    redCircle->draw();  // 输出: Drawing a Red circle.
    blueSquare->draw(); // 输出: Drawing a Blue square.

    delete red;
    delete blue;
    delete redCircle;
    delete blueSquare;

    return 0;
}
</syntaxhighlight>

=== 代码解释 ===
1. '''Color''' 是'''实现类接口'''，定义了颜色的抽象方法。
2. '''Red''' 和 '''Blue''' 是'''具体实现类'''，分别实现了红色和蓝色的具体逻辑。
3. '''Shape''' 是'''抽象类'''，包含一个对 '''Color''' 的引用。
4. '''Circle''' 和 '''Square''' 是'''扩展抽象类'''，实现了具体的形状绘制逻辑。
5. 在运行时，可以通过组合不同的形状和颜色来动态生成对象。

== 实际应用场景 ==
桥接模式在以下场景中非常有用：
* '''GUI开发'''：将窗口（抽象）与操作系统API（实现）分离。
* '''数据库驱动'''：将SQL语句（抽象）与不同数据库的实现（如MySQL、PostgreSQL）分离。
* '''设备驱动程序'''：将设备操作（抽象）与具体硬件实现分离。

=== 案例：跨平台图形渲染 ===
假设我们需要开发一个跨平台的图形渲染库，支持不同平台（Windows、Linux）和不同渲染API（OpenGL、Vulkan）。使用桥接模式可以避免为每个平台和API组合创建子类：

<syntaxhighlight lang="cpp">
// 实现类接口：渲染API
class RenderAPI {
public:
    virtual ~RenderAPI() = default;
    virtual void render() = 0;
};

// 具体实现类：OpenGL
class OpenGL : public RenderAPI {
public:
    void render() override {
        std::cout << "Rendering with OpenGL." << std::endl;
    }
};

// 具体实现类：Vulkan
class Vulkan : public RenderAPI {
public:
    void render() override {
        std::cout << "Rendering with Vulkan." << std::endl;
    }
};

// 抽象类：图形
class Graphic {
protected:
    RenderAPI* renderer;
public:
    Graphic(RenderAPI* renderer) : renderer(renderer) {}
    virtual ~Graphic() = default;
    virtual void draw() = 0;
};

// 扩展抽象类：圆形
class CircleGraphic : public Graphic {
public:
    CircleGraphic(RenderAPI* renderer) : Graphic(renderer) {}
    void draw() override {
        std::cout << "Drawing a circle: ";
        renderer->render();
    }
};

int main() {
    RenderAPI* opengl = new OpenGL();
    RenderAPI* vulkan = new Vulkan();

    Graphic* circle1 = new CircleGraphic(opengl);
    Graphic* circle2 = new CircleGraphic(vulkan);

    circle1->draw(); // 输出: Drawing a circle: Rendering with OpenGL.
    circle2->draw(); // 输出: Drawing a circle: Rendering with Vulkan.

    delete opengl;
    delete vulkan;
    delete circle1;
    delete circle2;

    return 0;
}
</syntaxhighlight>

== 优缺点 ==
=== 优点 ===
* 分离抽象与实现，提高扩展性。
* 避免多层继承导致的类爆炸问题。
* 符合开闭原则，新增抽象或实现时无需修改现有代码。

=== 缺点 ===
* 增加了系统的复杂度。
* 需要正确识别系统中变化的维度。

== 总结 ==
桥接模式通过组合代替继承，有效地处理多维度变化的系统设计。它在需要动态切换实现或避免类层次结构过深时特别有用。理解并正确应用桥接模式可以显著提高代码的可维护性和灵活性。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 设计模式]]