桥接模式通过抽象与实现分离，使二者独立变化。定义Implementor基类及子类实现具体操作，抽象类持实现指针，实现解耦与灵活扩展。
通过抽象与实现分离，使二者独立变化。定义Implementor基类及子类实现具体操作，抽象类持实现指针，实现解耦与灵活扩展。桥接模式的核心是把抽象和实现解耦，让两者可以独立变化。在C++中，通过将实现部分封装到一个独立的类层次中，并在抽象类中持有指向实现的指针，就可以实现这种分离。这样，修改实现不会影响抽象接口，扩展新功能也更灵活。
定义实现接口（Implementor）
先定义一个实现类的基类，它提供实现层面的接口。这个类通常是一个抽象基类，具体的实现由子类完成。
class Implementor {
public:
virtual ~Implementor() = default;
virtual void operationImpl() = 0;
};
比如，可以有两个具体实现：
class ConcreteImplementorA : public Implementor {
public:
void operationImpl() override {
std::cout << "ConcreteImplementorA operation\n";
}
};
class ConcreteImplementorB : public Implementor {
public:
void operationImpl() override {
std::cout << "ConcreteImplementorB operation\n";
}
};
定义抽象类（Abstraction）
抽象类包含一个指向Implementor的指针，通过组合方式引用实现。它提供高层接口，但实际工作委托给实现对象。
class Abstraction {
protected:
Implementor* impl;
public:
Abstraction(Implementor* i) : impl(i) {}
virtual ~Abstraction() = default;
virtual void operation() {
impl->operationImpl();
}
void setImplementor(Implementor* i) {
impl = i;
}};
这样可以在运行时切换不同的实现。
扩展抽象类（Refined Abstraction）
可以在抽象层进行扩展，而不影响实现部分。
class RefinedAbstraction : public Abstraction {
public:
RefinedAbstraction(Implementor* i) : Abstraction(i) {}
void operation() override {
std::cout << "RefinedAbstraction doing extra work...\n";
Abstraction::operation();
}};
使用示例
客户端代码可以根据需要组合不同的抽象和实现。
int main() {
Implementor* implA = new ConcreteImplementorA();
Implementor* implB = new ConcreteImplementorB();
Abstraction* abs1 = new Abstraction(implA);
Abstraction* abs2 = new RefinedAbstraction(implB);
abs1->operation(); // 输出: ConcreteImplementorA operation
abs2->operation();
// 输出:
// RefinedAbstraction doing extra work...
// ConcreteImplementorB operation
delete abs1;
delete abs2;
delete implA;
delete implB;
return 0;
}
基本上就这些。桥接模式的关键在于用组合代替继承，把可变的部分分离出去。C++中借助指针和多态，很容易实现这种结构。只要设计好接口，后续增加新的抽象或实现都无需改动原有代码，符合开闭原则。
