桥模式（Bridge Pattern）

定义

桥模式是一种结构型设计模式，其主要目的是将抽象部分与实现部分分离，使它们可以独立变化。这样可以更灵活地组合不同的抽象部分和实现部分，而不需要修改已有的代码。

桥模式（Bridge Pattern）之所以得名，是因为它提供了一种方式，使得软件系统的抽象部分（Abstraction）与实现部分（Implementation）可以相对独立地变化。这就像在一座桥上，桥的两侧分别代表了抽象部分和实现部分，桥身则连接了两者，使得它们可以独立地发展和变化，而不需要彼此紧密耦合。

在桥模式中，“桥”主要体现在将两个角色之间的继承关系改为聚合关系，也就是将抽象化与实现化之间的强关联改换成弱关联。这样，抽象部分和实现部分就可以通过组合/聚合关系来连接，而不是通过继承关系。这种设计使得抽象部分和实现部分可以独立地扩展和变化，而不会影响到对方。

因此，桥模式中的“桥”代表了抽象部分和实现部分之间的连接和通信机制，它使得两者可以独立地变化，提高了软件系统的灵活性和可维护性。

至于桥模式的具体应用场景，它通常用于处理那些具有多个独立变化维度的场景。例如，在处理图形界面时，图形和颜色可能是两个独立变化的维度。通过桥模式，我们可以将这两个维度拆分开来，使得它们可以独立地扩展和变化，而不会影响到彼此。

总之，桥模式中的“桥”代表了抽象部分和实现部分之间的连接和通信机制，它使得两者可以独立地变化，从而提高了软件系统的灵活性和可维护性。

桥模式基本结构

桥模式的组成

1. 抽象化（Abstraction）角色：定义抽象接口，并维护一个对实现化对象的引用。
2. 扩展抽象化（Refined Abstraction）角色：是抽象化角色的具体实现，实现化角色和抽象化角色之间的桥梁接口的实现。
3. 实现化（Implementor）角色：定义实现接口的接口。
4. 具体实现化（Concrete Implementor）角色：扩展实现化角色，实现实现化接口。

Abstraction（抽象类）

class Abstraction {
protected:
    Implementor* implementor;

public:
    Abstraction(Implementor* imp) : implementor(imp) {}
    virtual void operation() = 0;
};

RefinedAbstraction（具体抽象类）

class RefinedAbstraction : public Abstraction {
public:
    RefinedAbstraction(Implementor* imp) : Abstraction(imp) {}
    virtual void operation() override {
        // additional code
        implementor->operationImpl();
        // additional code
    }
};

Implementor（实现类接口）

class Implementor {
public:
    virtual void operationImpl() = 0;
};

ConcreteImplementor（具体实现类）

class ConcreteImplementorA : public Implementor {
public:
    virtual void operationImpl() override {
        // 实现 A 的具体操作
    }
};

class ConcreteImplementorB : public Implementor {
public:
    virtual void operationImpl() override {
        // 实现 B 的具体操作
    }
};

示例

考虑一个图形绘制的场景，其中有不同的图形（圆形、矩形）和不同的颜色（红色、蓝色）。每种图形都有绘图需要，而绘图需要设置颜色。所以这里绘制是抽象，设置颜色为具体实现。

我们可以使用桥模式来处理这种情况。

Abstraction - 图形抽象类

class Shape {
protected:
    Color* color;

public:
    Shape(Color* col) : color(col) {}
    virtual void draw() = 0;
};

RefinedAbstraction - 具体图形类

class Circle : public Shape {
public:
    Circle(Color* col) : Shape(col) {}
    virtual void draw() override {
        std::cout << "Draw Circle ";
        color->applyColor();
    }
};

class Rectangle : public Shape {
public:
    Rectangle(Color* col) : Shape(col) {}
    virtual void draw() override {
        std::cout << "Draw Rectangle ";
        color->applyColor();
    }
};

Implementor - 颜色接口

class Color {
public:
    virtual void applyColor() = 0;
};

ConcreteImplementor - 具体颜色类

class RedColor : public Color {
public:
    virtual void applyColor() override {
        std::cout << "with Red Color\n";
    }
};

class BlueColor : public Color {
public:
    virtual void applyColor() override {
        std::cout << "with Blue Color\n";
    }
};

使用桥模式，我们可以独立地变化图形和颜色，不影响彼此的变化。例如

int main() {
    Color* red = new RedColor();
    Color* blue = new BlueColor();

    Shape* circle = new Circle(red);
    Shape* rectangle = new Rectangle(blue);

    circle->draw();        // Draw Circle with Red Color
    rectangle->draw();     // Draw Rectangle with Blue Color

    // 清理内存...
    
    return 0;
}

在这个例子中，桥模式使得我们可以轻松地添加新的图形或颜色，而不需要修改已有的类。这样的设计符合开闭原则，使得系统更加灵活和可扩展。