Interviewer: Veuillez parler du modèle de pont
La partie abstraite et sa réalisation ont découplé la partie , de sorte que les deux peuvent être variées indépendamment.
Avantages du modèle
- Interface abstraite séparée et sa partie implémentation
- Peut remplacer le schéma d'héritage multicouche, réduisant considérablement le nombre de sous-classes
- Améliorer l'évolutivité du système, étendre arbitrairement l'une des deux dimensions changeantes, sans modifier le système d'origine, conformément au principe d'ouverture et de fermeture
Inconvénients du modèle
- Augmentera la difficulté de comprendre et de concevoir le système
- Il n'est pas facile d'identifier correctement les deux dimensions qui changent indépendamment dans le système
Environnement applicable
- Besoin d'ajouter plus de flexibilité entre l'abstraction et la réification pour éviter d'établir une relation d'héritage statique entre les deux niveaux
- La partie abstraite et la partie implémentation peuvent être étendues indépendamment par héritage sans affecter l'une l'autre
- Une classe a au moins deux dimensions qui changent indépendamment, et ces deux dimensions ou plus doivent être développées indépendamment
- Vous ne souhaitez pas utiliser l'héritage ou un système où le nombre de classes système augmente fortement en raison de l'héritage multicouche
Code du mode pont
/*
* @ Description: C++ Design Patterns___Bridge
* @ version: v1.0
* @ Author: WeissxJ
*/
#include<iostream>
class Implementor
{
public:
virtual ~Implementor() {
}
virtual void action() = 0;
// ...
};
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;
}
// ...
};
class Abstraction
{
public:
virtual ~Abstraction() {
}
virtual void operation() = 0;
// ...
};
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;
}