Entrevistador: Hable sobre el modelo de puente
La parte abstracta y su parte desacoplada de realización , de modo que ambas pueden variarse de forma independiente.
Ventajas del modelo
- Interfaz abstracta separada y su parte de implementación
- Puede reemplazar el esquema de herencia de múltiples capas, lo que reduce en gran medida el número de subclases
- Mejorar la escalabilidad del sistema, expandir una de las dos dimensiones cambiantes arbitrariamente, sin modificar el sistema original, conforme al principio de apertura y cierre.
Desventajas del modelo
- Aumentará la dificultad de comprender y diseñar el sistema.
- No es fácil identificar correctamente las dos dimensiones que cambian independientemente en el sistema.
Entorno aplicable
- Es necesario agregar más flexibilidad entre la abstracción y la cosificación para evitar establecer una relación de herencia estática entre los dos niveles.
- La parte abstracta y la parte de implementación se pueden extender de forma independiente por herencia sin que se afecten entre sí.
- Una clase tiene dos o más dimensiones que cambian independientemente, y estas dos o más dimensiones deben expandirse de forma independiente.
- No desea utilizar herencia o un sistema en el que el número de clases de sistema aumenta considerablemente debido a la herencia de múltiples capas.
Código de modo puente
/*
* @ 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;
}