El patrón de estrategia es un patrón de diseño de comportamiento que define una serie de algoritmos y encapsula cada algoritmo para que puedan reemplazarse entre sí, desacoplando el código del cliente y la implementación específica del algoritmo. De esta forma, el cliente puede elegir diferentes algoritmos de acuerdo a diferentes requerimientos sin modificar el código original.
C implementa el patrón de estrategia
#include <stdio.h>
#include <stdlib.h>
// 定义策略接口
typedef struct {
void (*execute)(void);
} Strategy;
// 具体策略1
void strategy1_execute(void) {
printf("Executing Strategy 1\n");
}
// 具体策略2
void strategy2_execute(void) {
printf("Executing Strategy 2\n");
}
// 客户端代码，使用策略接口
void client_code(Strategy* strategy) {
strategy->execute();
}
int main() {
// 创建策略对象
Strategy* strategy1 = (Strategy*)malloc(sizeof(Strategy));
strategy1->execute = strategy1_execute;
Strategy* strategy2 = (Strategy*)malloc(sizeof(Strategy));
strategy2->execute = strategy2_execute;
// 使用不同的策略
client_code(strategy1);
client_code(strategy2);
// 释放内存
free(strategy1);
free(strategy2);
return 0;
}
C++ implementa el patrón de estrategia
#include <iostream>
// 定义策略接口
class Strategy {
public:
virtual void execute() = 0;
virtual ~Strategy() {
}
};
// 具体策略1
class Strategy1 : public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy 1" << std::endl;
}
};
// 具体策略2
class Strategy2 : public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy 2" << std::endl;
}
};
// 客户端代码，使用策略接口
void client_code(Strategy* strategy) {
strategy->execute();
}
int main() {
// 使用不同的策略
Strategy1 strategy1;
Strategy2 strategy2;
client_code(&strategy1);
client_code(&strategy2);
return 0;
}
Ventajas y desventajas del patrón de estrategia.
ventaja:
Flexibilidad mejorada : el patrón de estrategia permite que el algoritmo varíe independientemente del uso del cliente. Los algoritmos se pueden seleccionar dinámicamente en tiempo de ejecución para responder de manera flexible a diferentes necesidades y escenarios.
Reutilización de código : cada estrategia puede ser compartida por varios clientes, evitando la duplicación de código.
Buena escalabilidad : cuando se necesita agregar un nuevo algoritmo, solo necesita agregar una nueva clase de estrategia sin modificar el código existente.
Facilidad de prueba : dado que la clase de estrategia encapsula el algoritmo concreto, es fácil realizar pruebas unitarias.
defecto:
Aumentar el número de clases : Cada estrategia específica requiere una clase correspondiente.Si hay muchas estrategias, se puede aumentar el número de clases, lo que aumenta la complejidad del mantenimiento del código.
El cliente debe comprender la estrategia : el código del cliente debe comprender todas las estrategias para poder elegir.Si hay muchas estrategias, la complejidad del código del cliente puede aumentar.
En general , el patrón de estrategia es adecuado para situaciones en las que es necesario seleccionar dinámicamente un algoritmo en tiempo de ejecución y se espera que el algoritmo y el código del cliente estén desacoplados. Para casos simples, puede que no sea necesario usar el patrón de estrategia, pero en escenarios complejos, puede conducir a una mejor capacidad de mantenimiento y escalabilidad.