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(){
    //用戶輸入的兩個(gè)操作數(shù)和一個(gè)操作符
    double number1, number2;
    char oper;
    std::cout << "Please enter a binary operation expressions(+-*/):\n";
    std::cin >> number1 >> oper >> number2;
    //聲明操作對(duì)象
    Operation<double> *operation = new Operation<double>;
    //聲明工廠對(duì)象
    Factory<double> factory;
    //利用工廠類(lèi)選擇運(yùn)算符并返回運(yùn)算對(duì)象(加減還是乘或除?）
    operation = factory.createOperate(oper);
    //設(shè)置兩個(gè)操作數(shù).（此處注意operation已經(jīng)是具體的派生類(lèi)運(yùn)算，調(diào)用setValue方法是繼承自基類(lèi)的）
    operation->setValue(number1, number2);
    if(operation != NULL){
        //計(jì)算結(jié)果，此處實(shí)際調(diào)用的是執(zhí)行運(yùn)算的派生類(lèi)的getResult()方法。即基類(lèi)指針指向派生類(lèi)
        double result = operation->getResult();
        std::cout << "Result is: " << result << std::endl;
    }else
        std::cout << "Input is invalid!\n";//輸入表達(dá)式不合法

    return 0;
}

Déclaration de classe (.h)

[code]//簡(jiǎn)單工廠模式---實(shí)現(xiàn)一個(gè)計(jì)算器
#ifndef _01SIMPLEFACTORY_H_
#define _01SIMPLEFACTORY_H_
//基類(lèi)， 運(yùn)算類(lèi)模板
template <typename T>
class Operation{
protected:
    //被派生類(lèi)繼承并使用
    T number1, number2;
public:
    //計(jì)算結(jié)果
    virtual T getResult();
    //設(shè)置兩個(gè)運(yùn)算值
    void setValue(T , T );  
};

//派生類(lèi)， 加法類(lèi)
template <typename T>
class Add: public Operation<T>{
public:
    //具體運(yùn)算方式， 重寫(xiě)基類(lèi)的方法
    T getResult()override;  
};

//派生類(lèi)， 減法類(lèi)
template <typename T>
class Sub: public Operation<T>{
public:
    //具體運(yùn)算方式， 重寫(xiě)基類(lèi)的方法
    T getResult()override;  
};

//派生類(lèi)， 乘法類(lèi)
template <typename T>
class Mul: public Operation<T>{
public:
    //具體運(yùn)算方式， 重寫(xiě)基類(lèi)的方法
    T getResult()override;  
};

//派生類(lèi)， 除法類(lèi)
template <typename T>
class Div: public Operation<T>{
public:
    //具體運(yùn)算方式， 重寫(xiě)基類(lèi)的方法
    T getResult()override;  
};

//簡(jiǎn)單工廠類(lèi)
template <typename T>
class Factory{
private:
    Operation<T> *operate;
public:
    //根據(jù)傳入的操作符，創(chuàng)建具體的運(yùn)算類(lèi)。返回運(yùn)算類(lèi)對(duì)象
    Operation<T>* createOperate(const char &op);
};
#endif

Implémentation de classe (.cpp)

[code]#include "01SimpleFactory.h"
#include <iostream>
//類(lèi)方法實(shí)現(xiàn)
template <typename T>
void Operation<T>::setValue(T v1, T v2){//設(shè)置兩個(gè)運(yùn)算值
    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不能作除數(shù)，可以作被除數(shù)
    if(number2 != 0){
        res = number1 / number2;
        return res;
    }
    std::cout << "0 cannot be used as a divisor\n";
    return 0;
}
//工廠方法,即工廠函數(shù)對(duì)其他操作類(lèi)根據(jù)功能選擇性的調(diào)用
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.miracleart.cn)?!