Patrones de diseño en C++ con ejemplos: guía completa

Patrones de diseño en C++ con ejemplos: de la A a la Z

Los patrones de diseño (design patterns) son soluciones probadas para problemas típicos que surgen durante el desarrollo de software. Para C++, estos patrones son especialmente importantes, ya que el lenguaje combina programación orientada a objetos, genérica y de bajo nivel. En este artículo, analizaremos los patrones de diseño clave en C++ con ejemplos de código que le ayudarán a escribir código más flexible, reutilizable y mantenible.

Consideraremos las tres categorías principales de patrones según la clasificación GoF (Gang of Four): creacionales, estructurales y de comportamiento. Cada patrón se ilustrará con un ejemplo real en C++.

1. Patrones creacionales (Creational Patterns)

Los patrones creacionales abstraen el proceso de creación de objetos, haciendo que el sistema sea independiente de cómo se crean, componen y representan los objetos.

1.1. Singleton (Instancia única)

Singleton garantiza que una clase tenga solo una instancia y proporciona un punto de acceso global a ella. En C++, a menudo se implementa a través de un objeto local estático (thread-safe desde C++11).

class Logger {public:    static Logger& getInstance() {        static Logger instance; // inicialización thread-safe        return instance;    }

    void log(const std::string& message) {        std::cout << "[LOG] " << message << std::endl;    }

private:    Logger() = default;    Logger(const Logger&) = delete;    Logger& operator=(const Logger&) = delete;};

// Usoint main() {    Logger::getInstance().log("Aplicación iniciada");    return 0;}

Cuándo usarlo: gestión de configuración, grupos de hilos, sistemas de registro.

1.2. Factory Method (Método de fábrica)

Factory Method define una interfaz para crear un objeto, pero permite que las subclases decidan qué clase instanciar.

class Product {public:    virtual void use() = 0;    virtual ~Product() = default;};

class ConcreteProductA : public Product {public:    void use() override { std::cout << "Producto A" << std::endl; }};

class ConcreteProductB : public Product {public:    void use() override { std::cout << "Producto B" << std::endl; }};

class Creator {public:    virtual Product* createProduct() = 0;    void someOperation() {        Product* p = createProduct();        p->use();        delete p;    }    virtual ~Creator() = default;};

class CreatorA : public Creator {public:    Product* createProduct() override { return new ConcreteProductA(); }};

class CreatorB : public Creator {public:    Product* createProduct() override { return new ConcreteProductB(); }};

Cuándo usarlo: cuando una clase no sabe qué objetos de subclase necesita crear.

2. Patrones estructurales (Structural Patterns)

Los patrones estructurales describen cómo las clases y los objetos pueden combinarse en estructuras más grandes, manteniendo la flexibilidad y la eficiencia.

2.1. Adapter (Adaptador)

Adapter permite que objetos con interfaces incompatibles trabajen juntos. En C++, a menudo se implementa mediante herencia o composición.

// Interfaz objetivoclass Target {public:    virtual void request() const {        std::cout << "Solicitud normal" << std::endl;    }    virtual ~Target() = default;};

// Clase adaptableclass Adaptee {public:    void specificRequest() const {        std::cout << "Solicitud específica" << std::endl;    }};

// Adaptador (mediante composición)class Adapter : public Target {private:    Adaptee* adaptee_;public:    Adapter(Adaptee* a) : adaptee_(a) {}    void request() const override {        adaptee_->specificRequest();    }};