Patrones de Diseño: Implementación en Python y C++ (Factory Method y Builder)

Por: Aldo Zanabria (www.zanabria.org)

Resumen

Los patrones de diseño constituyen soluciones probadas a problemas comunes en el desarrollo de software. Este artículo aborda la implementación de dos patrones fundamentales: Factory Method y Builder, primero en Python y luego traducidos a C++. Se muestra cómo los principios de abstracción, herencia y polimorfismo pueden aplicarse de forma similar en ambos lenguajes, con las particularidades propias de cada paradigma.

1. Introducción

En el ámbito del diseño de software, los patrones de diseño permiten desarrollar sistemas más robustos, mantenibles y reutilizables. Python, al ser un lenguaje dinámico, ofrece implementaciones más concisas; mientras que C++, como lenguaje fuertemente tipado y orientado a la eficiencia, exige estructuras más explícitas. Analizar la traducción de patrones entre ambos lenguajes es fundamental para comprender sus similitudes y diferencias.

En este trabajo se presentan dos ejemplos prácticos:

1. Factory Method: creación de objetos sin especificar su clase exacta.
2. Builder: construcción de objetos complejos de forma progresiva y flexible.

2. Patrón Factory Method

class Transporte:
    def entregar(self):
        pass

class Camion(Transporte):
    def entregar(self):
        return "Entrega por carretera"

class Barco(Transporte):
    def entregar(self):
        return "Entrega por mar"

class Factory:
    @staticmethod
    def get_transporte(tipo):
        if tipo == "camion":
            return Camion()
        elif tipo == "barco":
            return Barco()

t = Factory.get_transporte("barco")
print(t.entregar())

en c++

#include <iostream>
#include <memory>
#include <string>

class Transporte {
public:
    virtual std::string entregar() const = 0;
    virtual ~Transporte() {}
};

class Camion : public Transporte {
public:
    std::string entregar() const override {
        return "Entrega por carretera";
    }
};

class Barco : public Transporte {
public:
    std::string entregar() const override {
        return "Entrega por mar";
    }
};

class Factory {
public:
    static std::unique_ptr<Transporte> getTransporte(const std::string& tipo) {
        if (tipo == "camion") return std::make_unique<Camion>();
        if (tipo == "barco")  return std::make_unique<Barco>();
        return nullptr;
    }
};

int main() {
    auto t = Factory::getTransporte("barco");
    if (t) std::cout << t->entregar() << std::endl;
    return 0;
}

Análisis:

• Python permite flexibilidad gracias al tipado dinámico.
• C++ requiere clases abstractas (virtual puro) y punteros inteligentes (unique_ptr) para una gestión segura de memoria.

3. Patrón Builder

3.1. Ejemplo en Python

class Computadora:
    def __init__(self):
        self.cpu = None
        self.ram = None
        self.gpu = None

class Builder:
    def __init__(self):
        self.computadora = Computadora()

    def add_cpu(self, cpu):
        self.computadora.cpu = cpu
        return self

    def add_ram(self, ram):
        self.computadora.ram = ram
        return self

    def add_gpu(self, gpu):
        self.computadora.gpu = gpu
        return self

    def build(self):
        return self.computadora

pc = Builder().add_cpu("Intel i9").add_ram("32GB").add_gpu("RTX 4090").build()
print(vars(pc))

En C++

#include <iostream>
#include <string>

class Computadora {
public:
    std::string cpu;
    std::string ram;
    std::string gpu;

    void mostrar() const {
        std::cout << "CPU: " << cpu << "\n";
        std::cout << "RAM: " << ram << "\n";
        std::cout << "GPU: " << gpu << "\n";
    }
};

class Builder {
private:
    Computadora computadora;
public:
    Builder& add_cpu(const std::string& cpu) {
        computadora.cpu = cpu;
        return *this;
    }
    Builder& add_ram(const std::string& ram) {
        computadora.ram = ram;
        return *this;
    }
    Builder& add_gpu(const std::string& gpu) {
        computadora.gpu = gpu;
        return *this;
    }
    Computadora build() {
        return computadora;
    }
};

int main() {
    Computadora pc = Builder()
                        .add_cpu("Intel i9")
                        .add_ram("32GB")
                        .add_gpu("RTX 4090")
                        .build();
    pc.mostrar();
    return 0;
}

Análisis:

• Python maneja atributos dinámicamente con vars().
• C++ necesita métodos específicos (mostrar()) para imprimir.
• Ambos lenguajes permiten el encadenamiento de métodos devolviendo self (Python) o *this (C++).

4. Comparación entre Python y C++

Aspecto	Python	C++
Tipado	Dinámico	Estático y fuerte
Herencia	Implícita, simple	Requiere clases abstractas y virtual
Memoria	Automática (GC)	Manual, pero mejor con unique_ptr
Sintaxis	Concisa, flexible	Más detallada, control explícito
Encadenamiento	Devuelve self	Devuelve *this

5. Conclusiones

1. El patrón Factory Method permite encapsular la creación de objetos, delegando la decisión a un método centralizado. En C++, el uso de clases abstractas y punteros inteligentes garantiza seguridad y extensibilidad.
2. El patrón Builder facilita la construcción de objetos complejos paso a paso. Python ofrece gran flexibilidad, mientras que C++ requiere encadenamiento explícito con referencias.
3. La traducción de Python a C++ obliga a reflexionar sobre la gestión de memoria, la tipificación estricta y el uso de polimorfismo.
4. Estos ejemplos muestran que, pese a sus diferencias, los principios de diseño son universales, y su comprensión fortalece el desarrollo de software en cualquier lenguaje.

Fuentes:

·         Refactoring.Guru — «Factory Method» (en inglés)URL: https://refactoring.guru/design-patterns/factory-method

·         Refactoring.Guru — «Builder Pattern» (en inglés)
URL: https://refactoring.guru/design-patterns/builder

·         GeeksforGeeks — «Factory Method Design Pattern» (en inglés) URL: https://www.geeksforgeeks.org/factory-method-for-designing-pattern/

·         GeeksforGeeks — «Builder Pattern | C++ Design Patterns» (en inglés)
URL: https://www.geeksforgeeks.org/builder-pattern-c-design-patterns/

·         Wikipedia — «Builder pattern» (en inglés)
URL: https://en.wikipedia.org/wiki/Builder_pattern Wikipedia

·         Wikipedia — «Factory method pattern» (en inglés)
URL: https://en.wikipedia.org/wiki/Factory_method_pattern Wikipedia