桥接模式--结构型模式

1、描述

桥接是一种结构型模式，可将业务逻辑或一个大类拆分成为不同的层次结构，从而能独立的进行开发。

层次结构中的第一层（通常称为抽象部分）将包含对第二层（实现部分）对象的引用。抽象部分能将一些（有时是绝大部分）对自己的调用委派给实现部分的对象。所有的实现部分都有一个通用接口，因此他们能在抽象部分内部相互替换。

桥接模式的重点在“解耦”上。

优点： 1、抽象和实现分离； 2、优秀的扩充能力； 3、实现细节对客户透明

2、结构图

• Abstraction：提供高层控制逻辑，依赖于完成底层实际工作的实现对像
• Implementation：为所有具体实现声明通用接口。抽象部分仅能通过在这里声明的方法与实现对象交互
• ConcreateImplementations：包括特定的实现代码
• Refined Abstraction：提供控制逻辑的变体。与其父类一样，它们通过通用实现接口与不同的实现进行交互
• Client：仅关心如何与抽象部分合作。但是，Client需要将抽象对象与一个实现对象连接起来。

3、C++代码

#include <string>
#include <iostream>

// “实现部分”接口声明了在所有具体实现类中通用的方法。它不需要与“抽象部分”接口相
// 匹配。实际上，这两个接口可以完全不一样。通常实现接口只提供原语操作，而
// 抽象接口则会基于这些操作定义较高层次的操作。
class Implementation {
 public:
  virtual ~Implementation() {}
  virtual std::string OperationImplementation() const = 0;
};

//每个具体的实现类实现具体的接口功能
class ConcreteImplementationA : public Implementation {
 public:
  std::string OperationImplementation() const override {
    return "ConcreteImplementationA: Here's the result on the platform A.\n";
  }
};
class ConcreteImplementationB : public Implementation {
 public:
  std::string OperationImplementation() const override {
    return "ConcreteImplementationB: Here's the result on the platform B.\n";
  }
};

// “抽象部分”定义了两个类层次结构中“控制”部分的接口。它管理着一个指向“实
// 现部分”层次结构中对象的引用，并会将所有真实工作委派给该对象
class Abstraction {

 protected:
  Implementation* implementation_;

 public:
  Abstraction(Implementation* implementation) : implementation_(implementation) {
  }

  virtual ~Abstraction() {
  }

  virtual std::string Operation() const {
    return "Abstraction: Base operation with:\n" +
           this->implementation_->OperationImplementation();
  }
};

// 你可以独立于设备类的方式从抽象层中扩展类。
class ExtendedAbstraction : public Abstraction {
 public:
  ExtendedAbstraction(Implementation* implementation) : Abstraction(implementation) {
  }
  std::string Operation() const override {
    return "ExtendedAbstraction: Extended operation with:\n" +
           this->implementation_->OperationImplementation();
  }
};

//除了初始化阶段，抽象对象在这个阶段被链接对于特定的实现对象，client代码只应依赖于
//抽象类。这样client代码就可以支持任何抽象实现组合。
void ClientCode(const Abstraction& abstraction) {
  // ...
  std::cout << abstraction.Operation();
  // ...
}

//client代码应该能够使用任何预先配置的抽象实现组合。
int main() {
  Implementation* implementation = new ConcreteImplementationA;
  Abstraction* abstraction = new Abstraction(implementation);
  ClientCode(*abstraction);
  std::cout << std::endl;
  delete implementation;
  delete abstraction;

  implementation = new ConcreteImplementationB;
  abstraction = new ExtendedAbstraction(implementation);
  ClientCode(*abstraction);

  delete implementation;
  delete abstraction;

  return 0;
}

参考

https://refactoringguru.cn/