C++-Entwurfsmuster – kurze Einführung in einfache Factory-Muster

Einfache Factory-Definition: Implementieren Sie eine Factory-Funktion, um selektiv andere Betriebsklassen aufzurufen, um den tatsächlichen Anforderungen der Benutzer gerecht zu werden.

Die Aufteilung erforderlicher Funktionen in mehrere Komponenten kann die Codekopplung reduzieren und die Wiederverwendung von Code verbessern. Wenn sich der Bedarf an einer bestimmten Funktion in der Zukunft ändert, sind nur teilweise Änderungen erforderlich, sodass das gesamte System nicht beeinträchtigt wird, was die Effizienz erheblich verbessert.

Die objektorientierte Designidee besteht darin, die Kopplung des Programms durch Kapselung, Vererbung und Polymorphismus zu reduzieren, während Designmuster die Effizienz von OOP erhöhen. Durch die ordnungsgemäße Verwendung von Designmustern kann das Programm flexibler und einfacher gemacht werden ändern, wiederverwenden.

Bei der Unterscheidung funktionaler Komponenten gilt jedoch nicht: Je mehr Klassen, desto besser ist die Einteilung der Klassen, sondern die Grundlage der Klassifizierung ist eine abstrakte Sammlung von Objekten mit denselben Attributen Funktionen ist eine Klasse.

Hier implementieren wir einen Taschenrechner mit Additions-, Subtraktions-, Multiplikations- und Divisionsfunktionen, um die Implementierung und Anwendung des einfachen Fabrikmusters zu veranschaulichen.

Testfall

[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;
}

Deklaration der Klasse (.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

Implementierung der Klasse (.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;
}

Oben Es handelt sich um die Implementierung des einfachen Factory-Musters.

Zusammenfassung:

Das Erstellungsmuster abstrahiert den Instanziierungsprozess einer Klasse und kann die Erstellung von Objekten von der Verwendung von Objekten trennen.

Das einfache Factory-Muster wird auch als statisches Factory-Methodenmuster bezeichnet und gehört zum Klassenerstellungsmuster. Im einfachen Factory-Muster können Instanzen verschiedener Klassen gemäß unterschiedlichen Parametern zurückgegeben werden. Das einfache Factory-Muster definiert speziell eine Klasse, die für die Erstellung von Instanzen anderer Klassen verantwortlich ist. Die erstellten Instanzen haben normalerweise eine gemeinsame übergeordnete Klasse.

Das einfache Factory-Muster enthält drei Rollen: Die Factory-Rolle ist für die Implementierung der internen Logik zum Erstellen aller Instanzen verantwortlich; die abstrakte Produktrolle ist die übergeordnete Klasse aller erstellten Objekte und für die Beschreibung der gemeinsamen öffentlichen Schnittstelle verantwortlich an alle Instanzen; die spezifische Produktrolle Eine Rolle ist ein Erstellungsziel und alle erstellten Objekte fungieren als Instanzen einer bestimmten Klasse dieser Rolle.

Der Kernpunkt des einfachen Factory-Musters ist: Wenn Sie etwas benötigen, müssen Sie nur einen korrekten Parameter übergeben, um das benötigte Objekt zu erhalten, ohne die Details seiner Erstellung zu kennen.

Der größte Vorteil des einfachen Factory-Musters besteht darin, die Erstellung von Objekten und die Verwendung von Objekten zu trennen und die Erstellung von Objekten an spezialisierte Factory-Klassen zu übergeben. Der größte Nachteil besteht jedoch darin, dass die Factory-Klassen vorhanden sind Nicht flexibel genug und neue spezifische Elemente hinzugefügt. Das Produkt muss den Beurteilungslogikcode der Fabrikklasse ändern. Wenn viele Produkte vorhanden sind, ist der Fabrikmethodencode sehr kompliziert.

Zu den anwendbaren Situationen des einfachen Factory-Musters gehören: Die Factory-Klasse ist für die Erstellung relativ weniger Objekte verantwortlich. Der Client kennt nur die an die Factory-Klasse übergebenen Parameter und kümmert sich nicht darum, wie die Objekte erstellt werden.

Das Obige ist eine kurze Einführung in das einfache Factory-Muster in C++-Entwurfsmustern. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!