桥模式（Bridge Pattern）

定义

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

桥模式基本结构

桥模式的组成

抽象化（Abstraction）角色：定义抽象接口，并维护一个对实现化对象的引用。
扩展抽象化（Refined Abstraction）角色：是抽象化角色的具体实现，实现化角色和抽象化角色之间的桥梁接口的实现。
实现化（Implementor）角色：定义实现接口的接口。
具体实现化（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;
}

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

不是杠杠