【设计模式之桥接模式 -- C++】-CSDN博客

本文链接：https://blog.csdn.net/qq_44628330/article/details/139583107

桥接模式 – 抽象和现实，解耦合

桥接模式（Bridge Pattern）是一种结构型设计模式，它主要解决的是“将抽象与实现解耦，使得两者可以独立地变化”。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现两者的解耦。桥接模式

组成

抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化对象的引用。
扩展抽象化（Refined Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。
实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化角色调用。
具体实现化（Concrete Implementor）角色：实现实现化角色接口，具体实现业务方法。

好处

分离抽象和实现：桥接模式可以将抽象部分和实现部分分离，这样可以使两者可以独立地变化。
提高扩展性：由于桥接模式把抽象和实现分离了，所以扩展能力强。我们可以独立地改变或者扩展抽象部分和实现部分。
增加了系统的灵活性：抽象和实现的分离为复杂的类层次结构提供了系统设计的自由。一个类的实现不再受到其他类的影响，可以独立地进行设计。
实现细节对客户透明：可以对客户隐藏实现细节，减少了客户程序与系统实现部分的耦合度，使得系统更易于扩展和维护。

使用场景

桥接模式适用于以下场景：

不希望在抽象和实现部分之间有固定的绑定关系：例如，如果一个软件的功能需求频繁变动，你不希望因为改变了实现方式，导致需要同时更改抽象层的代码，那么使用桥接模式可以使得抽象层和实现层可以独立地变化。
类的抽象以及它的实现都应该可以通过生成子类的方法加以扩展：这时候的抽象类和实现类可以分别独立地变化，而不会相互影响，这就需要桥接模式。
对于那些不希望使用继承或因为多层继承导致系统类的个数急剧增加的系统：使用桥接模式可以避免类的个数急剧增加，同时也可以减少继承带来的复杂性。
类的实现应对客户透明：如果你希望类的实现不影响到使用类的客户，那么桥接模式可以隐藏实现的细节，使得变化不会传递到客户端。

实现

实现一个基类

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

定义两个子类

// 定义一个子类:实现者1
class ConcreteImplementor1 : public Implementor {
public:
    void Operation() override {
        cout << "ConcreteImplementor1: Operation.\n";
    }
};

// 定义一个子类:实现者2
class ConcreteImplementor2 : public Implementor {
public:
    void Operation() override {
        cout << "ConcreteImplementor2: Operation.\n";
    }
};

定义一个抽象类

class Abstraction
{
public:
    virtual void Operation() = 0;
};

定义两个抽象子类

// 定义一个子类:抽象类1
class RefinedAbstraction1 : public Abstraction {
public:
    RefinedAbstraction1(Implementor *implementor) {
        implementor_ = implementor;
    }

    void Operation() override {
        cout << "RefinedAbstraction1: Operation.\n";
        implementor_->Operation();
    }

private:
    Implementor *implementor_;
};

// 定义一个子类:抽象类2
class RefinedAbstraction2 : public Abstraction {
public:
    RefinedAbstraction2(Implementor *implementor) {
        implementor_ = implementor;
    }

    void Operation() override {
        cout << "RefinedAbstraction2: Operation.\n";
        implementor_->Operation();
    }

private:

    Implementor *implementor_;
};

测试

int main() {
    Implementor *implementor1 = new ConcreteImplementor1;
    Implementor *implementor2 = new ConcreteImplementor2;

    Abstraction *abstraction1 = new RefinedAbstraction1(implementor1);
    Abstraction *abstraction2 = new RefinedAbstraction2(implementor2);

    abstraction1->Operation();
    abstraction2->Operation();

    delete implementor1;
    delete implementor2;
    delete abstraction1;
    delete abstraction2;

    return 0;
}

输出

RefinedAbstraction1: Operation.
ConcreteImplementor1: Operation.
RefinedAbstraction2: Operation.
ConcreteImplementor2: Operation.