橋接模式（Bridge）

參考：

橋接設計模式 (refactoringguru.cn)

橋接模式（Bridge模式）詳解 (biancheng.net)

design-patterns-cpp/bridge at master · JakubVojvoda/design-patterns-cpp · GitHub

 

一、什麼是橋接模式？

定義：將抽象與實現分離，用組合關系代替繼承，從不同的維度進行擴展。
 
簡單來說，就是A類中包含有B類接口，通過構造函數傳遞B類的實現，這個B類就是橋。
 
比如模型玩具有很多種，紅色的球體、藍色的球體、紅色的正方體、藍色的正方體等。可以按形狀、按顏色等兩個維度的進行劃分。A類錶示形狀，B類錶示顏色。(維度可以有多個，以組合方式實現)

 

二、示例

橋接（Bridge）模式包含以下主要角色：

1. 抽象化（Abstraction）角色：定義抽象類，並包含一個對實現化對象的引用。
2. 擴展抽象化（Refined Abstraction）角色：是抽象化角色的子類，實現父類中的業務方法，並通過組合關系調用實現化角色中的業務方法。
3. 實現化（Implementor）角色：定義實現化角色的接口，供擴展抽象化角色調用。
4. 具體實現化（Concrete Implementor）角色：給出實現化角色接口的具體實現。

 

1、Bridge.cpp

/*
 * C++ Design Patterns: Bridge
 * Author: Jakub Vojvoda [github.com/JakubVojvoda]
 * 2016
 *
 * Source code is licensed under MIT License
 * (for more details see LICENSE)
 *
 */

#include <iostream>

/*
 * Implementor
 * 實現化角色：定義實現化角色的接口，供擴展抽象化角色調用。
 */
class Implementor
{
public:
  virtual ~Implementor() {}
  
  virtual void action() = 0;
  // ...
};

/*
 * Concrete Implementors
 * 具體實現化角色：給出實現化角色接口的具體實現。
 */
class ConcreteImplementorA : public Implementor
{
public:
  ~ConcreteImplementorA() {}
  
  void action()
  {
    std::cout << "Concrete Implementor A" << std::endl;
  }
  // ...
};

class ConcreteImplementorB : public Implementor
{
public:
  ~ConcreteImplementorB() {}
  
  void action()
  {
    std::cout << "Concrete Implementor B" << std::endl;
  }
  // ...
};

/*
 * Abstraction
 * 抽象化角色：定義抽象類接口。
 */
class Abstraction
{
public:
  virtual ~Abstraction() {}
  
  virtual void operation() = 0;
  // ...
};

/*
 * RefinedAbstraction
 * 擴展抽象化角色：實現父類中的業務接口，並通過組合關系調用實現化角色中的業務方法。
 */
class RefinedAbstraction : public Abstraction
{
public:
  ~RefinedAbstraction() {}
  
  RefinedAbstraction(Implementor *impl) : implementor(impl) {}
  
  void operation()
  {
    implementor->action();
  }
  // ...

private:
  Implementor *implementor;
};


int main()
{
  Implementor *ia = new ConcreteImplementorA;
  Implementor *ib = new ConcreteImplementorB;
  
  Abstraction *abstract1 = new RefinedAbstraction(ia);
  abstract1->operation();
  
  Abstraction *abstract2 = new RefinedAbstraction(ib);
  abstract2->operation();
  
  delete abstract1;
  delete abstract2;
  
  delete ia;
  delete ib;
  
  return 0;
}

 

2、不同顏色的模型

 

 

#include <iostream>

class Color
{
public:
  virtual ~Color() {}
  
  virtual void show() = 0;
};

class Red : public Color
{
public:
  ~Red() {}
  
  void show() override
  {
    std::cout << "Color is red." << std::endl;
  }
};

class Blue : public Color
{
public:
  ~Blue() {}
  
  void show() override
  {
    std::cout << "Color is blue." << std::endl;
  }
};

class Model
{
public:
  virtual ~Model() {}
  
  virtual void show() = 0;
};

// 正方體模型
class CubeModel : public Model
{
public:
  ~CubeModel() {}
  
  CubeModel(Color *c) : color(c) {}
  
  void show() override
  {
    std::cout << "I am Cube." << std::endl;
    color->show();
  }

private:
  Color *color;
};

// 球體模型
class SphereModel : public Model
{
public:
  ~SphereModel() {}
  
  SphereModel(Color *c) : color(c) {}
  
  void show() override
  {
    std::cout << "I am Sphere." << std::endl;
    color->show();
  }

private:
  Color *color;
};


int main()
{
  Color *red = new Red();
  Color *blue = new Blue();
  
  CubeModel *cube = new CubeModel(red);
  cube->show();
  
  SphereModel *sphere = new SphereModel(blue);
  sphere->show();
  
  delete cube;
  delete sphere;
  
  delete red;
  delete blue;
  
  return 0;
}

 

三、優缺點，適用場景

優點

• 符合開閉原則，抽象與實現分離，擴展能力强。
• 單一職責原則，抽象部分專注於處理高層邏輯，實現部分處理平臺細節。

缺點

• 由於聚合關系建立在抽象層，要求開發者能正確地識別出系統中兩個獨立變化的維度。
• 對高內聚的類使用該模式可能會讓代碼更加複雜。