Factory y Abstract Factory
Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 92 de 104.
El patrón Factory delega la creación de objetos a un método o una clase independiente, lo que te permite crear objetos sin especificar su clase exacta. Esto resulta útil cuando la lógica de creación es compleja o cuando quieres desacoplar el código cliente de las implementaciones concretas.
Una fábrica simple utiliza un método que devuelve distintos tipos derivados según la entrada:
#include <iostream>
#include <memory>
class Button {
public:
virtual void render() = 0;
virtual ~Button() = default;
};
class WindowsButton : public Button {
public:
void render() override { std::cout << "Windows button\n"; }
};
class MacButton : public Button {
public:
void render() override { std::cout << "Mac button\n"; }
};
// Función de fábrica
std::unique_ptr<Button> createButton(const std::string& os) {
if (os == "windows") return std::make_unique<WindowsButton>();
if (os == "mac") return std::make_unique<MacButton>();
return nullptr;
}La Fábrica abstracta va un paso más allá al crear familias de objetos relacionados. En lugar de un método de fábrica, tienes una interfaz de fábrica con varios métodos de creación:
class Checkbox {
public:
virtual void check() = 0;
virtual ~Checkbox() = default;
};
class WindowsCheckbox : public Checkbox {
public:
void check() override { std::cout << "Windows checkbox\n"; }
};
class MacCheckbox : public Checkbox {
public:
void check() override { std::cout << "Mac checkbox\n"; }
};
// Fábrica abstracta
class GUIFactory {
public:
virtual std::unique_ptr<Button> createButton() = 0;
virtual std::unique_ptr<Checkbox> createCheckbox() = 0;
virtual ~GUIFactory() = default;
};
class WindowsFactory : public GUIFactory {
public:
std::unique_ptr<Button> createButton() override {
return std::make_unique<WindowsButton>();
}
std::unique_ptr<Checkbox> createCheckbox() override {
return std::make_unique<WindowsCheckbox>();
}
};Usa el patrón de fábrica cuando necesites crear objetos de forma flexible, y el patrón de fábrica abstracta cuando necesites asegurarte de que los objetos relacionados funcionen juntos de manera coherente.
Desafío
FácilConstruyamos un sistema de generación de documentos usando los patrones Factory y Abstract Factory. Crearás un sistema que puede generar distintos tipos de documentos (informes y facturas) en diferentes formatos de salida (PDF y HTML), y demostrarás cómo las fábricas desacoplan la creación de objetos del código cliente.
Organizarás tu código en cuatro archivos:
Document.h: Define la jerarquía de productos de documentos.Crea una clase base abstracta
Documentcon un método virtual purogenerate()que devuelva una cadena que describa el documento generado, y un destructor virtual.Después, crea cuatro clases concretas de documentos:
PDFReport:generate()devuelve"Generating PDF Report"HTMLReport:generate()devuelve"Generating HTML Report"PDFInvoice:generate()devuelve"Generating PDF Invoice"HTMLInvoice:generate()devuelve"Generating HTML Invoice"
DocumentFactory.h: Implementa una función de fábrica simple y una fábrica abstracta.Primero, crea una función de fábrica simple llamada
createDocumentque acepte dos cadenas: un tipo de documento ("report"o"invoice") y un formato ("pdf"o"html"). Debe devolver unstd::unique_ptr<Document>que apunte al documento concreto correspondiente. Devuelvenullptrpara las combinaciones no válidas.Después, crea una clase de fábrica abstracta llamada
DocumentFactorycon dos métodos virtuales puros:createReport(): devuelve unstd::unique_ptr<Document>createInvoice(): devuelve unstd::unique_ptr<Document>
Implementa dos fábricas concretas:
PDFFactory: creaPDFReportyPDFInvoiceHTMLFactory: creaHTMLReportyHTMLInvoice
DocumentService.h: Crea un servicio que use la fábrica abstracta.Define una clase
DocumentServicecuyo constructor acepte unstd::unique_ptr<DocumentFactory>. Debe tener un método llamadogenerateAllDocuments()que use la fábrica para crear un informe y una factura, y luego imprima el resultado de llamar agenerate()en cada uno, uno por línea.main.cpp: Demuestra ambos enfoques de fábrica.Lee dos entradas:
- Un tipo de documento (
reportoinvoice) - Un formato (
pdfohtml)
Primero, usa la función de fábrica simple para crear un documento según las entradas. Imprime el resultado de llamar a
generate()en él.Después, imprime una línea en blanco.
A continuación, crea un
DocumentServicecon la fábrica correspondiente al formato ingresado (usaPDFFactoryparapdfyHTMLFactoryparahtml). Llama agenerateAllDocuments()para mostrar cómo la fábrica abstracta crea una familia de documentos relacionados.- Un tipo de documento (
Por ejemplo, con las entradas report y pdf:
Generating PDF Report
Generating PDF Report
Generating PDF InvoiceCon las entradas invoice y html:
Generating HTML Invoice
Generating HTML Report
Generating HTML InvoiceObserva cómo la fábrica simple crea un único documento según ambos parámetros, mientras que la fábrica abstracta garantiza que todos los documentos creados por un servicio compartan el mismo formato. Esta es la principal ventaja de Abstract Factory cuando necesitas familias de objetos relacionados que funcionen juntos de manera coherente.
Pruébalo tú mismo
#include <iostream>
#include <string>
#include <memory>
#include "Document.h"
#include "DocumentFactory.h"
#include "DocumentService.h"
using namespace std;
int main() {
// Lee las entradas
string documentType;
string format;
cin >> documentType;
cin >> format;
// TODO: Usa la función de fábrica simple para crear un documento
// basado en las entradas documentType y format
// Imprime el resultado de llamar a generate() en él
// Imprime una línea en blanco
cout << endl;
// TODO: Crea un DocumentService con la fábrica adecuada
// según la entrada format (PDFFactory para "pdf", HTMLFactory para "html")
// Llama a generateAllDocuments() para mostrar cómo funciona la fábrica abstracta
return 0;
}
Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.
Todas las lecciones de Programación Orientada a Objetos
1Fundamentos de la POO
Archivos externosCompilación y construcción en C++Archivos de cabecera y archivos fuenteEspacios de nombres y ámbitoIntroducción a la POO en C++Clases y objetosEl puntero 'this'Métodos (funciones miembro)Atributos (miembros de datos)Fundamentos de constructores y destructoresRepaso: calculadora sencilla4Propiedades de clase
Miembros de instancia vs. estáticosGetters y settersFunciones miembro constPalabra clave mutableMétodos y variables estáticosFunciones y clases friendRepaso: gestor de cuentas bancarias7Herencia
Herencia básicaNiveles de acceso en la herenciaOrden de llamada de constructores y destructoresSobrescritura de métodosFunciones virtuales y VTableHerencia múltipleHerencia virtualRepaso: jerarquía de empleados10Visión general de STL
Visión general y filosofía de STLContenedores de STLIteradoresAlgoritmos de STLFunctores y expresiones lambdaRepaso: frecuencia de palabras13Patrones de diseño, parte 1
Introducción a los patrones de diseñoPatrón SingletonFactory y Abstract FactoryPatrón BuilderPatrón ObserverPatrón Strategy2Gestión de memoria
Memoria de pila vs. heapPunteros y referenciasMemoria dinámica (new/delete)Punteros inteligentes en C++RAII en C++Repaso: gestor de arreglos dinámicos5Encapsulación
Especificadores de acceso en C++Especificadores de acceso en profundidadOcultación de informaciónStruct vs. classClases anidadas e internasRepaso: sistema de registros de estudiantes8Polimorfismo
Polimorfismo en compilación y en tiempo de ejecuciónSobrecarga de funcionesRepaso de las funciones virtualesFunciones virtuales purasClases abstractasDiseño de interfaces en C++Conversión dinámica y RTTIRepaso: calculadora de formas11Conceptos avanzados de POO
Composición frente a herenciaMixins mediante CRTPIdiom PimplBorrado de tiposClases enum y tipado fuerteManejo de excepciones en POOJerarquías de excepciones personalizadas14Patrones de diseño, parte 2
Patrón CommandPatrón AdapterPatrón DecoratorPatrón Template MethodPatrón StatePatrón CompositeRAII como patrón3Constructores y destructores
Constructor predeterminadoConstructor con parámetrosConstructor de copiaConstructor de movimientoListas de inicialización del constructorConstructores delegadosAnálisis detallado del destructorRegla de tres / cinco / ceroRepaso: clase String6Sobrecarga de operadores
Introducción a la sobrecarga de operadoresSobrecarga de operadores aritméticosSobrecarga de operadores de comparaciónOperadores de flujoSobrecarga del operador de asignaciónSobrecarga de los operadores [] y ()Operadores de conversión de tipoRepaso: clase Matrix9Plantillas
Plantillas de funcionesPlantillas de clasesEspecialización de plantillasPlantillas variádicasFundamentos de SFINAE y rasgos de tiposRepaso: contenedor genéricoPractica por tu cuenta: Compilador de C++ online