桥接模式

桥接模式（Bridge Pattern）是一种结构型设计模式。它将杂糅在一起的类拆分为抽象和实现两个独立的层次结构。这两个层次独立变化，互不影响。

角色

1. 抽象部分（Abstraction）： 定义抽象部分的接口，维护一个指向实现部分的引用。
2. 扩展抽象部分（Refined Abstraction）： 继承自抽象部分，对抽象部分进行扩展，可以增加新的方法或属性。
3. 实现部分（Implementor）： 定义实现部分的接口，被抽象部分调用。
4. 具体实现部分（Concrete Implementor）： 实现实现部分的接口，提供具体的功能。

适用场景

• 当抽象化和实现化需要独立变化时。
• 当需要在多个维度上扩展系统时。

类图

代码

#include <iostream>

// 实现部分接口
class Implementor {
public:
    virtual void operationImpl() const = 0;
};

// 具体实现部分A
class ConcreteImplementorA : public Implementor {
public:
    void operationImpl() const override {
        std::cout << "Concrete Implementor A operation." << std::endl;
    }
};

// 具体实现部分B
class ConcreteImplementorB : public Implementor {
public:
    void operationImpl() const override {
        std::cout << "Concrete Implementor B operation." << std::endl;
    }
};

// 抽象部分接口
class Abstraction {
public:
    Abstraction(Implementor* impl)
        : implementor(impl) {}

    virtual void operation() const = 0;

protected:
    Implementor* implementor;
};

// 扩展抽象部分
class RefinedAbstraction : public Abstraction {
public:
    RefinedAbstraction(Implementor* impl)
        : Abstraction(impl) {}

    void operation() const override {
        std::cout << "Refined Abstraction operation." << std::endl;
        implementor->operationImpl();
    }
};

int main() {
    // 创建具体实现部分对象
    Implementor* concreteImplA = new ConcreteImplementorA();
    Implementor* concreteImplB = new ConcreteImplementorB();

    // 创建扩展抽象部分对象，关联具体实现部分对象
    Abstraction* abstractionA = new RefinedAbstraction(concreteImplA);
    Abstraction* abstractionB = new RefinedAbstraction(concreteImplB);

    // 调用操作
    abstractionA->operation();
    abstractionB->operation();

    // 释放资源
    delete concreteImplA;
    delete concreteImplB;
    delete abstractionA;
    delete abstractionB;

    return 0;
}