Modèle de conception C brève introduction au modèle d'usine simple

Définition d'usine simple : implémentez une fonction d'usine pour appeler de manière sélective d'autres classes d'opérations afin de répondre aux besoins réels des utilisateurs.

La division des fonctions requises en plusieurs composants peut réduire le couplage de code et améliorer la réutilisation du code. Lorsque la demande pour une certaine fonction évolue dans le futur, seules des modifications partielles sont nécessaires, de sorte que l'ensemble du système ne soit pas affecté, ce qui améliore considérablement l'efficacité.

L'idée de la conception orientée objet est de réduire le couplage du programme via l'encapsulation, l'héritage et le polymorphisme, tandis que les modèles de conception augmentent l'efficacité de la POO. Une utilisation appropriée des modèles de conception peut rendre le programme plus flexible et plus simple. modifier, Réutiliser.

Cependant, lors de la distinction des composants fonctionnels, ce n'est pas que plus il y a de classes, mieux c'est. La division des classes est destinée à l'encapsulation, mais la base de la classification est l'abstraction d'une collection abstraite d'objets avec les mêmes attributs et. les fonctions sont une classe.

Ici, nous allons implémenter une calculatrice avec des fonctions d'addition, de soustraction, de multiplication et de division pour illustrer la mise en œuvre et l'application du modèle d'usine simple.

Cas de test

[code]int main(){
    //用户输入的两个操作数和一个操作符
    double number1, number2;
    char oper;
    std::cout << "Please enter a binary operation expressions(+-*/):\n";
    std::cin >> number1 >> oper >> number2;
    //声明操作对象
    Operation<double> *operation = new Operation<double>;
    //声明工厂对象
    Factory<double> factory;
    //利用工厂类选择运算符并返回运算对象(加减还是乘或除?）
    operation = factory.createOperate(oper);
    //设置两个操作数.（此处注意operation已经是具体的派生类运算，调用setValue方法是继承自基类的）
    operation->setValue(number1, number2);
    if(operation != NULL){
        //计算结果，此处实际调用的是执行运算的派生类的getResult()方法。即基类指针指向派生类
        double result = operation->getResult();
        std::cout << "Result is: " << result << std::endl;
    }else
        std::cout << "Input is invalid!\n";//输入表达式不合法

    return 0;
}

Déclaration de classe (.h)

[code]//简单工厂模式---实现一个计算器
#ifndef _01SIMPLEFACTORY_H_
#define _01SIMPLEFACTORY_H_
//基类， 运算类模板
template <typename T>
class Operation{
protected:
    //被派生类继承并使用
    T number1, number2;
public:
    //计算结果
    virtual T getResult();
    //设置两个运算值
    void setValue(T , T );  
};

//派生类， 加法类
template <typename T>
class Add: public Operation<T>{
public:
    //具体运算方式， 重写基类的方法
    T getResult()override;  
};

//派生类， 减法类
template <typename T>
class Sub: public Operation<T>{
public:
    //具体运算方式， 重写基类的方法
    T getResult()override;  
};

//派生类， 乘法类
template <typename T>
class Mul: public Operation<T>{
public:
    //具体运算方式， 重写基类的方法
    T getResult()override;  
};

//派生类， 除法类
template <typename T>
class Div: public Operation<T>{
public:
    //具体运算方式， 重写基类的方法
    T getResult()override;  
};

//简单工厂类
template <typename T>
class Factory{
private:
    Operation<T> *operate;
public:
    //根据传入的操作符，创建具体的运算类。返回运算类对象
    Operation<T>* createOperate(const char &op);
};
#endif

Implémentation de classe (.cpp)

[code]#include "01SimpleFactory.h"
#include <iostream>
//类方法实现
template <typename T>
void Operation<T>::setValue(T v1, T v2){//设置两个运算值
    number1 = v1;
    number2 = v2;
}
template <typename T>
T Operation<T>::getResult(){
    return 0;
}
template <typename T>
T Add<T>::getResult(){
    T res = number1 + number2;
    return res;
}
template <typename T>
T Sub<T>::getResult(){
    T res = number1 - number2;
    return res;
}
template <typename T>
T Mul<T>::getResult(){
    T res = number1 * number2;
    return res;
}
template <typename T>
T Div<T>::getResult(){
    double res = 0;
    //0不能作除数，可以作被除数
    if(number2 != 0){
        res = number1 / number2;
        return res;
    }
    std::cout << "0 cannot be used as a divisor\n";
    return 0;
}
//工厂方法,即工厂函数对其他操作类根据功能选择性的调用
template <typename T>
Operation<T>* Factory<T>::createOperate(const char &op){
    switch(op){
    case &#39;+&#39;:
        operate = new Add<T>;
        break;
    case &#39;-&#39;:
        operate = new Sub<T>;
        break;    
    case &#39;*&#39;:
        operate = new Mul<T>;
        break;    
    case &#39;/&#39;:
        operate = new Div<T>;
        break;
    default:
        operate = NULL;
        break;  
    }
    return operate;
}

Ci-dessus Il s’agit de la mise en œuvre du modèle d’usine simple.

Résumé :

Le modèle de création abstrait le processus d'instanciation d'une classe et peut séparer la création d'objets de l'utilisation d'objets.

Le modèle de fabrique simple est également appelé modèle de méthode de fabrique statique, qui appartient au modèle de création de classe. Dans le modèle d'usine simple, les instances de différentes classes peuvent être renvoyées en fonction de différents paramètres. Le modèle de fabrique simple définit spécifiquement une classe responsable de la création d'instances d'autres classes. Les instances créées ont généralement une classe parent commune.

Le modèle d'usine simple contient trois rôles : le rôle d'usine est responsable de la mise en œuvre de la logique interne de création de toutes les instances ; le rôle de produit abstrait est la classe parent de tous les objets créés et est responsable de la description de l'interface publique commune. à toutes les instances ; le rôle de produit spécifique. Un rôle est une cible de création et tous les objets créés agissent comme des instances d'une classe spécifique de ce rôle.

Le point clé du modèle d'usine simple est le suivant : lorsque vous avez besoin de quelque chose, il vous suffit de passer un paramètre correct pour obtenir l'objet dont vous avez besoin sans connaître les détails de sa création.

Le plus grand avantage du modèle d'usine simple est de séparer la création d'objets et l'utilisation d'objets, et de confier la création d'objets à des classes d'usine spécialisées. Cependant, son plus grand inconvénient est que les classes d'usine sont. pas assez flexible et ajouter de nouveaux produits spécifiques. Le produit doit modifier le code logique de jugement de la classe d'usine, et lorsqu'il y a beaucoup de produits, le code de méthode d'usine sera très compliqué.

Les situations applicables du modèle d'usine simple incluent : la classe d'usine est responsable de la création de relativement peu d'objets ; le client ne connaît que les paramètres transmis à la classe d'usine et ne se soucie pas de la façon de créer les objets.

Ce qui précède est le contenu d'une brève introduction au modèle de conception C et au modèle d'usine simple. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !