C ++ Patrón de diseño-Patrón de fábrica Método de fábrica

Motivación

• En los sistemas de software, a menudo nos enfrentamos a la tarea de crear objetos; debido a los cambios en los requisitos, los tipos específicos de objetos que deben crearse a menudo cambian.
• ¿Cómo lidiar con este cambio? ¿Cómo evitar el método convencional de creación de objetos (nuevo) y proporcionar un "mecanismo de encapsulación" para evitar el acoplamiento estrecho entre el programa cliente y este "trabajo de creación de objetos concretos"?

Definición del patrón

Defina una interfaz para crear objetos y permita que las subclases decidan qué clase instanciar. El método de fábrica retrasa la creación de instancias de una clase (propósito: desacoplamiento, significa: función virtual) a subclases. - "Modo de diseño" GoF

Ejemplos de patrones

El ejemplo del divisor de archivos se mencionó anteriormente en el modo de observador . Aquí usaremos el ejemplo del divisor de archivos para ilustrar. El divisor de archivos puede tener más de un divisor de archivos binarios, y también puede tener un divisor de archivos de texto, un divisor de archivos de imagen, un divisor de archivos de video, etc. Ante diferentes necesidades, a menudo es necesario crear diferentes tipos específicos.

class ISplitter {
 public :
     virtual  void split () = 0 ;
    virtual ~ ISplitter () {} 
}; 

clase BinarySplitter: public ISplitter { 

}; 

clase TxtSplitter: public ISplitter { 

}; 

class PictureSplitter: public ISplitter { 

}; 

clase VideoSplitter: public ISplitter { 

}; 

clase MainForm: public Form { 
    TextBox * txtFilePath; 
    Caja de texto* txtFileNumber; 
    ProgressBar * progressBar; 

public :
     void Button1_Click () 
    { 

        ISplitter * splitter = new BinarySplitter (); // 依赖 具体 类 divisor- 
        > split (); 

    } 
};

Pero una vez que el diseño ha cambiado de esta manera, el código debe cambiarse constantemente y el divisor depende de la clase de implementación específica.

Usar el modo de fábrica puede resolver este problema. Define una interfaz para crear objetos y permite que las subclases decidan qué clase instanciar. Los métodos de fábrica retrasan la creación de instancias de una clase en subclases.

// 抽象 类
class ISplitter {
 public :
     virtual  void split () = 0 ;
    virtual ~ ISplitter () {} 
}; 


// 工厂 基 类
clase SplitterFactory {
 public :
     virtual ISplitter * CreateSplitter () = 0 ;
    virtual ~ SplitterFactory () {} 
}; 


// 具体 类
clase BinarySplitter: public ISplitter { 
    
}; 

clase TxtSplitter: public ISplitter { 
    
}; 

clasePictureSplitter: public ISplitter { 
    
}; 

clase VideoSplitter: public ISplitter { 
    
}; 

// 具体 工厂
clase BinarySplitterFactory: public SplitterFactory {
 public :
     virtual ISplitter * CreateSplitter () {
         return  new BinarySplitter (); 
    } 
}; 

clase TxtSplitterFactory: public SplitterFactory {
 public :
     virtual ISplitter * CreateSplitter () {
         return  new TxtSplitter ();
    } 
}; 

class PictureSplitterFactory: public SplitterFactory {
 public :
     virtual ISplitter * CreateSplitter () {
         return  new PictureSplitter (); 
    } 
}; 

clase VideoSplitterFactory: public SplitterFactory {
 public :
     virtual ISplitter * CreateSplitter () {
         return  new VideoSplitter (); 
    } 
}; 


clase MainForm: forma pública 
{ 
    SplitterFactory * factory; //工厂
público: 
    El MainForm (SplitterFactory *   Fábrica) {
         el este -> Fábrica = fábrica; // distinguir miembro de la función de parámetros 
    }
     anula la Button1_Click () { 
        iSplitter * = divisor de fábrica> CreateSplitter (); // polimórfica nueva nueva 
        Splitter> split () ; 
    } 
}; 

// MainForm ya no depende de clases concretas

Estructura

Resumen de puntos principales

• El patrón Método de fábrica se utiliza para aislar la relación de acoplamiento entre el usuario del objeto de clase y el tipo específico . Frente a un tipo específico que cambia con frecuencia, el acoplamiento estrecho (nuevo) puede generar software frágil.
• El patrón Método de fábrica utiliza un enfoque orientado a objetos para diferir el trabajo de los objetos específicos que se crearán en subclases, implementando así una estrategia de extensión (en lugar de cambio) que resuelve mejor esta relación estrechamente acoplada.
• El modelo del Método de fábrica aborda las necesidades cambiantes de los "objetos individuales". La desventaja es que el método / parámetros de creación son los mismos.

Codigo basico

#include <iostream>
 usando el  espacio de nombres estándar; 

clase Producto {
 public :
     virtual ~ Product () {}
     virtual  void Operation () = 0 ; 
}; 

clase ConcreteProductA: public Product {
 public :
     void Operation () {cout << " ConcreteProductA " << endl; } 
}; 

clase ConcreteProductB: public Producto {
 public :
     void Operation () {cout << "ConcreteProductB " << endl;} 
}; 

class Creator {
 public :
     virtual Product * FactoryMethod () = 0 ;
     virtual ~ Creator () {} 
}; 

class ConcreteCreatorA: public Creator {
 public : 
    Product * FactoryMethod () { return  new ConcreteProductA ( );} 
}; 

clase ConcreteCreatorB: public Creator {
 public : 
    Product * FactoryMethod () { return  newConcreteProductB (); } 
}; 

int main () { 
    Creator * ca = new ConcreteCreatorA (); 
    Producto * pa = ca-> FactoryMethod (); 
    pa -> Operación (); // ConcreteProductA 

    Creator * cb = new ConcreteCreatorB (); 
    Producto * pb = cb-> FactoryMethod (); 
    pb -> Operación (); // ConcreteProductB 

    delete ca;
    eliminar pa;
    eliminar cb;
    eliminar pb; 

    devuelve  0 ; 
}