Annuaire d'articles
Préface
Cet article vous amène officiellement à apprendre les modèles de conception en C++. Cet article vous amène principalement à apprendre le modèle d'usine.
1. Qu'est-ce que le mode usine ?
Factory Pattern est un modèle de conception créationnel qui fournit une interface pour créer des objets, mais retarde l'instanciation d'objets spécifiques vers des sous-classes ou des classes d'usine spécifiques. Le modèle d'usine dissocie le code client du processus de création d'objets spécifiques, de sorte que le code client n'a pas besoin de s'appuyer directement sur la méthode de création d'objets spécifiques, mais crée des objets via des usines, améliorant ainsi la flexibilité et la maintenabilité du code.
En C++, le modèle d'usine peut être implémenté de différentes manières, notamment un modèle d'usine simple, un modèle de méthode d'usine et un modèle d'usine abstrait.
Diagramme de structure UML :
2. Mode usine simple
Le modèle d'usine simple encapsule le processus de création d'objet via une classe d'usine. Le client transmet différents paramètres à la classe d'usine, et la classe d'usine crée différents objets spécifiques en fonction des différents paramètres. Un avantage majeur du modèle de fabrique simple est que la logique de création d'objets est centralisée dans une classe de fabrique. Le code client n'a besoin d'interagir qu'avec la classe de fabrique, plutôt que directement avec des objets spécifiques.
Exemple de code :
#include <iostream>
using namespace std;
// 抽象产品接口
class Product
{
public:
virtual void use() = 0;
};
// 具体产品类A
class ConcreteProductA : public Product
{
public:
void use()
{
cout << "Using ConcreteProductA\n";
}
};
// 具体产品类B
class ConcreteProductB : public Product
{
public:
void use()
{
cout << "Using ConcreteProductB\n";
}
};
//工厂类
class Factory
{
public:
static Product* CreateProduct(int type)
{
if (type == 1)
{
return new ConcreteProductA();
}
else if (type == 2)
{
return new ConcreteProductB();
}
else
{
return NULL;
}
}
};
int main(void)
{
Product* productA = Factory::CreateProduct(1);
productA->use();
Product* productB = Factory::CreateProduct(2);
productB->use();
delete productA;
delete productB;
return 0;
}
3. Avantages et inconvénients du modèle d'usine simple
优点：
La logique de création d'objets est centralisée dans une classe factory. Le client n'a qu'à interagir avec la classe factory sans prêter attention au processus de création d'objets spécifiques, ce qui réduit la complexité du code client.
Le code client est découplé des objets spécifiques et différents objets peuvent être créés via des classes d'usine sans modifier le code client, ce qui améliore la flexibilité et l'évolutivité du code.
Le code client n'a besoin que de connaître l'interface abstraite du produit sans connaître les détails du produit spécifique, réalisant ainsi le principe d'inversion de dépendance.
Les détails d'implémentation de produits spécifiques peuvent être masqués, ce qui améliore la sécurité du code.
缺点：
En violation du principe d'ouverture et de fermeture, pour chaque nouveau produit spécifique, la logique de création de la classe usine doit être modifiée, ce qui peut rendre le code de la classe usine trop volumineux.
La classe usine concentre toute la logique de création d'objets. Lorsqu'il existe plusieurs produits spécifiques, le code de la classe usine deviendra complexe et difficile à maintenir et à étendre.
La classe d'usine dans le modèle d'usine simple est responsable de la création de tous les produits spécifiques.Lorsque des produits spécifiques sont ajoutés, la classe d'usine deviendra surchargée et ne respectera pas le principe de responsabilité unique.
4. Scénarios simples applicables en usine
1. La logique de création de l'objet est relativement simple : lorsque la logique de l'objet à créer est relativement simple et n'implique pas de jugements conditionnels ou d'algorithmes complexes, le modèle d'usine simple peut être utilisé.
2. Les détails de création d'objets spécifiques doivent être cachés du code client : grâce au modèle d'usine simple, le client n'a besoin que d'interagir avec la classe d'usine et n'a pas besoin d'interagir directement avec des objets spécifiques. Il peut encapsuler et encapsuler les détails de création d'objets spécifiques.
3. Différents objets doivent être créés en fonction de différents paramètres : lorsque vous devez créer différents objets spécifiques en fonction de différents paramètres ou configurations, vous pouvez utiliser le modèle d'usine simple. Le client n'a qu'à donner les paramètres correspondants, et la classe factory crée l'objet correspondant en fonction des différents paramètres.
4. Le nombre d'objets est relativement stable : si le nombre d'objets dans le système est fixe et ne change pas fréquemment, et qu'il n'est pas nécessaire d'ajouter fréquemment de nouveaux objets spécifiques, le modèle d'usine simple peut simplifier la création et la gestion des objets. .
5. Utilisation d'une classe d'usine simple
Dans Qt, le processus de création et de gestion de divers objets peut être réalisé à l'aide du modèle d'usine, particulièrement courant dans la programmation de l'interface utilisateur. Voici un exemple simple montrant comment utiliser le modèle d'usine dans Qt pour créer différents types de fenêtres :
Tout d’abord, nous devons définir une classe de fenêtre abstraite (AbstractWindow) comme interface produit de l’usine pour représenter différents types d’objets fenêtre.
class AbstractWindow : public QWidget
{
public:
virtual void display() = 0;
};
Ensuite, nous pouvons créer des classes de fenêtre spécifiques (par exemple : MainWindow, DialogWindow, PopupWindow) qui héritent de la classe de fenêtre abstraite et implémentent ses méthodes correspondantes.
class MainWindow : public AbstractWindow
{
public:
void display() override
{
// 实现MainWindow的显示逻辑
}
};
class DialogWindow : public AbstractWindow
{
public:
void display() override
{
// 实现DialogWindow的显示逻辑
}
};
class PopupWindow : public AbstractWindow
{
public:
void display() override
{
// 实现PopupWindow的显示逻辑
}
};
Ensuite, nous devons créer une classe de fabrique de fenêtres (WindowFactory) pour créer les types correspondants d'objets fenêtre basés sur différents paramètres.
class WindowFactory
{
public:
static AbstractWindow* createWindow(const QString& windowType)
{
if (windowType == "MainWindow")
{
return new MainWindow();
}
else if (windowType == "DialogWindow")
{
return new DialogWindow();
}
else if (windowType == "PopupWindow")
{
return new PopupWindow();
}
return nullptr;
}
};
Dans le code client, nous pouvons utiliser la classe window factory pour créer des objets fenêtre spécifiques.
QString windowType = "MainWindow"; // 可以根据需求指定不同的窗口类型
AbstractWindow* window = WindowFactory::createWindow(windowType);
if (window)
{
window->display();
delete window;
}
Grâce au code ci-dessus, nous pouvons utiliser le mode usine pour créer des objets de fenêtre correspondants en fonction de différents types de fenêtres et exécuter leur logique d'affichage spécifique.
Dans cet exemple, la classe de fenêtre abstraite agit comme l'interface produit de l'usine, la classe de fenêtre concrète est le produit créé par l'usine et la classe de fabrique de fenêtres est la classe qui implémente spécifiquement le modèle d'usine. En utilisant le modèle d'usine, nous pouvons dissocier efficacement la création et l'utilisation d'objets de fenêtre et rendre le programme plus flexible et évolutif.
Résumer
Cet article l'expliquera ici.