CKTIS / C++
Singleton, fábrica y decorador en C++: arquitectura y modelo de objetos
Estos tres patrones separan la identidad y la vida útil de un objeto, la elección de la implementación que se construye y la ampliación del comportamiento sin cambiar la interfaz.
Versión: ISO C++23; implementation support may vary
Sintaxis
// C++23 architecture/object-model patterns (representative declarations, not special language syntax).
#include <memory>
#include <string>
// Singleton
class Style final {
public:
static const Style& instance();
Style(const Style&) = delete;
Style& operator=(const Style&) = delete;
char opening() const;
char closing() const;
private:
Style() = default;
~Style() = default;
};
struct Message {
virtual ~Message() = default;
virtual std::string text() const = 0;
};
// Factory
enum class Kind { brief, full };
std::unique_ptr<Message> make_message(Kind kind);
// Decorator
class Bracketed final : public Message {
public:
Bracketed(std::unique_ptr<Message> inner, const Style& style);
std::string text() const override;
private:
std::unique_ptr<Message> inner_;
char opening_;
char closing_;
};Alcance: arquitectura y modelo de objetos. Son patrones de diseño, no sintaxis especial de C++23. Singleton determina qué instancia comparten los clientes; la fábrica decide qué objeto crear; el decorador decide qué comportamiento añadir a un objeto existente.
Singleton. Style::instance() devuelve una referencia const no propietaria al mismo objeto static local a la función. Un constructor privado y las operaciones de copia eliminadas impiden que los clientes construyan o copien instancias directamente. Si hace falta inicialización dinámica, se realiza al pasar por primera vez por la declaración, y las llamadas concurrentes esperan a que termine. Esto no sincroniza las modificaciones posteriores. El objeto se destruye al finalizar el programa normalmente; no lo uses tras su destrucción ni des por hecha una sola instancia para todos los plugins. Pasa la dependencia explícitamente si no necesitas acceso global.
Fábrica. make_message(Kind) elige Brief o Full en tiempo de ejecución, crea un objeto nuevo con std::make_unique y transfiere la propiedad exclusiva mediante std::unique_ptr<Message>. Un valor no admitido lanza std::invalid_argument en vez de devolver un puntero nulo. Es una función de fábrica simple, no un método virtual del patrón Factory Method ni una Abstract Factory para familias de productos relacionados.
Decorador. Bracketed implementa la misma interfaz Message y adquiere la propiedad exclusiva del objeto envuelto mediante std::move. Rechaza un puntero nulo con std::invalid_argument. Copia los caracteres de Style en vez de conservar una referencia. text() delega en el objeto envuelto y añade corchetes. Los decoradores pueden anidarse y su orden puede cambiar el resultado. El destructor virtual de Message permite a std::unique_ptr<Message> con su eliminador predeterminado destruir correctamente un objeto derivado.
Ejemplos
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
class Style final {
public:
static const Style& instance() {
static const Style style;
return style;
}
Style(const Style&) = delete;
Style& operator=(const Style&) = delete;
char opening() const { return '['; }
char closing() const { return ']'; }
private:
Style() = default;
~Style() = default;
};
struct Message {
virtual ~Message() = default;
virtual std::string text() const = 0;
};
struct Brief final : Message {
std::string text() const override { return "brief"; }
};
struct Full final : Message {
std::string text() const override { return "full"; }
};
enum class Kind { brief, full };
std::unique_ptr<Message> make_message(Kind kind) {
switch (kind) {
case Kind::brief: return std::make_unique<Brief>();
case Kind::full: return std::make_unique<Full>();
}
throw std::invalid_argument("unsupported message kind");
}
class Bracketed final : public Message {
public:
Bracketed(std::unique_ptr<Message> inner, const Style& style)
: inner_(std::move(inner)),
opening_(style.opening()), closing_(style.closing()) {
if (!inner_) {
throw std::invalid_argument("missing wrapped message");
}
}
std::string text() const override {
return opening_ + inner_->text() + closing_;
}
private:
std::unique_ptr<Message> inner_;
char opening_;
char closing_;
};
int main() {
const auto& style = Style::instance();
auto plain = make_message(Kind::brief);
std::unique_ptr<Message> decorated =
std::make_unique<Bracketed>(make_message(Kind::full), style);
std::cout << std::boolalpha << (&style == &Style::instance()) << '\n'
<< plain->text() << '\n'
<< decorated->text() << '\n';
}
Resultado
true brief [full]
Líneas esperadas: `true` confirma que es la misma instancia, `brief` es el resultado del objeto sin decorar y `[full]` el de la segunda implementación tras decorarla.
Lecciones relacionadas
- C++ · Lección 55 · Intermedio · Versión: 2
Fuentes
- Declaration statement [stmt.dcl]
- The inline specifier [dcl.inline]
- Termination [basic.start.term]
- Virtual functions [class.virtual]
- Delete [expr.delete]
- Unique-ownership pointers: Creation [unique.ptr.create]
- unique_ptr for single objects: Constructors [unique.ptr.single.ctor]
- unique_ptr for single objects: Destructor [unique.ptr.single.dtor]
- Default deleters [unique.ptr.dltr.dflt]