Modèle de stratégie du modèle de conception comportementale [Série de modèles de conception]

Répertoire des articles de la série

Série de compétences C++ Série
d'architecture de communication Linux Série
de programmation d'optimisation haute performance C++ Série
de compréhension approfondie de la conception d'architecture logicielle Série de modèles de conception
de programmation de threads simultanés C++ avancés

Dans l'attente de votre attention! ! !

现在的一切都是为将来的梦想编织翅膀，让梦想在现实中展翅高飞。
Now everything is for the future of dream weaving wings, let the dream fly in reality.

1. Introduction au mode stratégie

⚠️ 意图：
Définissez une série d'algorithmes, encapsulez-les un par un et rendez-les interchangeables.

⚠️ 主要解决：
Dans le cas de plusieurs algorithmes similaires, utiliser if...else est compliqué et difficile à maintenir.

⚠️ 何时使用：
Un système a beaucoup, beaucoup de classes, et ce qui les distingue est leur comportement immédiat.

⚠️ 如何解决：
Encapsulez ces algorithmes dans des classes une par une et remplacez-les arbitrairement.

Dans Strategy Pattern, le comportement d'une classe ou de son algorithme peut être modifié au moment de l'exécution. Ce type de modèle de conception est un modèle comportemental.
Le modèle de stratégie définit une série d'algorithmes ou de stratégies et encapsule chaque algorithme dans une classe indépendante afin qu'ils puissent se remplacer. En utilisant le modèle de stratégie, différents algorithmes peuvent être sélectionnés au moment de l'exécution selon les besoins sans modifier le code client.
Dans le modèle de stratégie, nous créons des objets représentant diverses stratégies et un objet de contexte dont le comportement change à mesure que l'objet de stratégie change. Un objet de stratégie modifie l'algorithme d'exécution d'un objet de contexte.

Figure 1_1 Diagramme de classes de modèle de stratégie

Deuxièmement, les avantages et les inconvénients du modèle de stratégie

2.1 Avantages

1. L'algorithme peut être commuté librement. 2. Évitez d'utiliser plusieurs jugements conditionnels. 3. Bonne évolutivité.

2.2 Inconvénients

1. Il y aura plus de stratégies. 2. Toutes les catégories de politiques doivent être exposées au monde extérieur.

3. Scénarios d'utilisation du mode Stratégie

1. S'il existe de nombreuses classes dans un système et que la différence entre elles n'est que leur comportement, l'utilisation du modèle de stratégie peut permettre dynamiquement à un objet de choisir un comportement parmi de nombreux comportements. 2. Un système doit choisir dynamiquement l'un des nombreux algorithmes. 3. Si un objet a de nombreux comportements, s'il n'y a pas de mode approprié, ces comportements doivent être réalisés en utilisant plusieurs instructions de sélection conditionnelle.

4. Réalisation du mode stratégie

ReplaceAlgorithm est une classe abstraite qui définit l'interface de l'algorithme. Il existe trois classes héritées de cette classe abstraite, c'est-à-dire l'implémentation spécifique de l'algorithme. L'algorithme de remplacement doit être utilisé dans la classe Cache, donc un objet ReplaceAlgorithm est maintenu.

Dans un premier temps, la définition de l'algorithme de remplacement est donnée.

//抽象接口
class ReplaceAlgorithm
{
    
    
public:
	virtual void Replace() = 0;
};
//三种具体的替换算法
class LRU_ReplaceAlgorithm : public ReplaceAlgorithm
{
    
    
public:
	void Replace() {
    
     cout<<"Least Recently Used replace algorithm"<<endl; }
};
 
class FIFO_ReplaceAlgorithm : public ReplaceAlgorithm
{
    
    
public:
	void Replace() {
    
     cout<<"First in First out replace algorithm"<<endl; }
};
class Random_ReplaceAlgorithm: public ReplaceAlgorithm
{
    
    
public:
	void Replace() {
    
     cout<<"Random replace algorithm"<<endl; }
};

Donnez ensuite la définition de Cache, qui est très importante ici. La mise en œuvre de Cache affecte directement la façon dont les clients l'utilisent. La clé réside dans la façon de spécifier l'algorithme de remplacement.

Méthode 1 : spécifiez directement les paramètres et transmettez un pointeur vers un algorithme spécifique.

//Cache需要用到替换算法
class Cache
{
    
    
private:
	ReplaceAlgorithm *m_ra;
public:
	Cache(ReplaceAlgorithm *ra) {
    
     m_ra = ra; }
	~Cache() {
    
     delete m_ra; }
	void Replace() {
    
     m_ra->Replace(); }
};

Si cette méthode est utilisée, les clients doivent connaître les définitions spécifiques de ces algorithmes. Il ne peut être utilisé que de la manière suivante, et vous pouvez voir que trop de détails sont exposés.

int main()
{
    
    
	Cache cache(new LRU_ReplaceAlgorithm()); //暴露了算法的定义
	cache.Replace();
	return 0;
}

Méthode 2 : Il est également spécifié directement via des paramètres, mais au lieu de passer un pointeur, il s'agit d'une étiquette. De cette façon, les clients n'ont besoin de connaître que l'étiquette correspondante de l'algorithme, et n'ont pas besoin de connaître la définition spécifique de l'algorithme.

//Cache需要用到替换算法
enum RA {
    
    LRU, FIFO, RANDOM}; //标签
class Cache
{
    
    
private:
	ReplaceAlgorithm *m_ra;
public:
	Cache(enum RA ra) 
	{
    
     
		if(ra == LRU)
			m_ra = new LRU_ReplaceAlgorithm();
		else if(ra == FIFO)
			m_ra = new FIFO_ReplaceAlgorithm();
		else if(ra == RANDOM)
			m_ra = new Random_ReplaceAlgorithm();
		else 
			m_ra = NULL;
	}
	~Cache() {
    
     delete m_ra; }
	void Replace() {
    
     m_ra->Replace(); }
};

Par rapport à la méthode 1, cette méthode est beaucoup plus pratique à utiliser. En fait, cette méthode combine le modèle d'usine simple et le modèle de stratégie. La définition de l'algorithme utilise le modèle de stratégie, et la définition du Cache utilise en fait le modèle d'usine simple.

int main()
{
    
    
	Cache cache(LRU); //指定标签即可
	cache.Replace();
	return 0;
}

Dans les deux méthodes ci-dessus, le constructeur requiert des paramètres formels. Les constructeurs peuvent-ils ne prendre aucun paramètre ? La troisième implémentation est donnée ci-dessous.

Méthode 3 : Utilisez des modèles pour implémenter. L'algorithme est spécifié par les arguments du modèle. Bien sûr, les paramètres sont toujours utilisés, mais pas les paramètres du constructeur. En mode stratégie, le passage de paramètres est inévitable et le client doit spécifier un certain algorithme.

//Cache需要用到替换算法
template <class RA>
class Cache
{
    
    
private:
	RA m_ra;
public:
	Cache() {
    
     }
	~Cache() {
    
     }
	void Replace() {
    
     m_ra.Replace(); }
};

L'utilisation est la suivante :

int main()
{
    
    
	Cache<Random_ReplaceAlgorithm> cache; //模板实参
	cache.Replace();
	return 0;
}