Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Singleton, fábrica e decorador em C++: arquitetura e modelo de objetos

Os três padrões separam a identidade e o tempo de vida de um objeto, a escolha da implementação a construir e a adição de comportamento sem alterar a interface.

Versão: ISO C++23; implementation support may vary

Sintaxe

// 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_;
};

Âmbito — arquitetura e modelo de objetos. São padrões de desenho, não sintaxe especial de C++23. O singleton determina a instância que os clientes partilham; a fábrica escolhe o objeto a criar; o decorador decide que comportamento acrescentar a um objeto existente.

Singleton. Style::instance() devolve uma referência const não proprietária para o mesmo objeto static local à função. Um construtor privado e as operações de cópia eliminadas impedem que os clientes construam ou copiem instâncias diretamente. Se for necessária inicialização dinâmica, esta ocorre na primeira passagem pela declaração, e as chamadas concorrentes aguardam a sua conclusão. Isto não sincroniza alterações posteriores. O objeto é destruído no término normal do programa; não o uses após a destruição nem pressuponhas uma instância única para todos os plugins. Prefere passar a dependência explicitamente se não for necessário acesso global.

Fábrica. make_message(Kind) escolhe Brief ou Full em tempo de execução, cria um novo objeto com std::make_unique e transfere a propriedade exclusiva através de std::unique_ptr<Message>. Um valor não suportado lança std::invalid_argument em vez de devolver um ponteiro nulo. É uma função de fábrica simples, não um método virtual do padrão Factory Method nem uma Abstract Factory para famílias de produtos relacionados.

Decorador. Bracketed implementa a mesma interface Message e assume a propriedade exclusiva do objeto envolvido através de std::move. Rejeita um ponteiro nulo com std::invalid_argument. Copia os caracteres de Style sem guardar uma referência. text() delega no objeto envolvido e acrescenta parênteses retos. É possível encaixar decoradores, e a ordem pode alterar o resultado. O destrutor virtual de Message permite que std::unique_ptr<Message>, com o mecanismo de destruição predefinido, destrua corretamente um objeto derivado.

Exemplos

#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]

Linhas esperadas: `true` confirma a mesma instância, `brief` é o resultado do objeto sem decoração e `[full]` é o resultado da segunda implementação depois de decorada.

Lições relacionadas

  • C++ · Lição 55 · Intermédio · Versão: 2

Fontes