Mode pont

RÉFÉRENCES：

Mode de conception du pont (refactoringguru.cn)

Mode pont（BridgeMode）Détails (biancheng.net)

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

 

Un.、Qu'est - ce que le mode pont？

Définition：Séparer l'abstraction de la mise en oeuvre,Remplacer l'héritage par une relation combinatoire,Extensions à partir de différentes dimensions.
 
En termes simples,C'estALa classe contientBInterface de classe,Passer par le constructeurBMise en œuvre de la classe,C'estBLa classe est un pont..
 
Par exemple, il existe de nombreux types de jouets modèles,La sphère rouge、La sphère bleue、Le carré rouge、Carrés bleus, etc.Peut être en forme、Diviser par deux dimensions telles que la couleur.ALa classe représente la forme,BClasse pour la couleur.(Les dimensions peuvent être multiples,Mise en œuvre combinée)

 

2.、Exemple

Pont（Bridge）Le schéma contient les principaux rôles suivants:：

1. Abstraction（Abstraction）Rôle：Définir une classe abstraite,Et contient une référence à l'objet implémenté.
2. Extension de l'abstraction（Refined Abstraction）Rôle：Est une sous - classe de personnages abstraits,Mettre en œuvre les méthodes d'affaires dans la classe mère,Et appeler les méthodes d'affaires dans les rôles de mise en oeuvre par des relations composites.
3. Réalisation（Implementor）Rôle：Définir l'interface pour les rôles de mise en oeuvre,Pour les appels de rôle abstraits étendus.
4. Réalisation concrète（Concrete Implementor）Rôle：Donner la mise en oeuvre concrète de l'interface de rôle de mise en oeuvre.

 

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
 * Rôle de mise en oeuvre：Définir l'interface pour les rôles de mise en oeuvre,Pour les appels de rôle abstraits étendus.
 */
class Implementor
{
public:
  virtual ~Implementor() {}
  
  virtual void action() = 0;
  // ...
};

/*
 * Concrete Implementors
 * Rôles de mise en oeuvre spécifiques：Donner la mise en oeuvre concrète de l'interface de rôle de mise en oeuvre.
 */
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
 * Rôle abstrait： Définir une interface de classe abstraite .
 */
class Abstraction
{
public:
  virtual ~Abstraction() {}
  
  virtual void operation() = 0;
  // ...
};

/*
 * RefinedAbstraction
 * Extension des rôles abstraits： Implémenter l'interface d'affaires dans la classe parent ,Et appeler les méthodes d'affaires dans les rôles de mise en oeuvre par des relations composites.
 */
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、 Modèles de couleurs différentes

 

 

#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;
};

//  Modèle carré 
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;
};

//  Modèle sphérique 
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;
}

 

Trois、Avantages et inconvénients,Scénarios applicables

Avantages

• Conformément au principe d'ouverture et de fermeture, Séparation de l'abstraction et de la mise en oeuvre ,Forte capacité d'expansion.
• Principe de la responsabilité unique,La partie abstraite se concentre sur le traitement de la logique de haut niveau,Mise en œuvre partielle des détails de la plateforme.

Inconvénients

• Parce que les relations d'agrégation sont établies au niveau de l'abstraction, Exiger que les développeurs identifient correctement deux dimensions du système qui changent indépendamment .
• L'utilisation de ce schéma pour les classes fortement cohésives peut compliquer le Code .