CKTIS / C++
Singleton, fabrique et décorateur en C++ : architecture et modèle objet
Ces trois patrons séparent l’identité et la durée de vie d’un objet, le choix de l’implémentation à construire et l’ajout d’un comportement sans changer l’interface.
Version : ISO C++23; implementation support may vary
Syntaxe
// 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_;
};Périmètre — architecture et modèle objet. Il s’agit de patrons de conception, pas d’une syntaxe propre à C++23. Le singleton détermine quelle instance les clients partagent ; la fabrique choisit quel objet créer ; le décorateur décide quel comportement ajouter à un objet existant.
Singleton. Style::instance() renvoie une référence const non propriétaire vers le même objet local static. Un constructeur privé et des opérations de copie supprimées empêchent les clients de construire ou de copier directement des instances. Si une initialisation dynamique est nécessaire, elle a lieu au premier passage par la déclaration et les appels concurrents attendent sa fin. Cela ne synchronise pas les modifications ultérieures. L’objet est détruit lors de la fin normale du programme ; ne l’utilisez pas après sa destruction et ne supposez pas qu’une instance unique est partagée par tous les plugins. Préférez passer la dépendance explicitement si un accès global n’est pas nécessaire.
Fabrique. make_message(Kind) sélectionne Brief ou Full à l’exécution, crée un nouvel objet avec std::make_unique et en transfère la propriété exclusive via std::unique_ptr<Message>. Une valeur non prise en charge déclenche std::invalid_argument au lieu de produire un pointeur nul. C’est une simple fonction de fabrique, non une méthode virtuelle du patron Factory Method ni une Abstract Factory pour des familles de produits apparentés.
Décorateur. Bracketed implémente la même interface Message et prend la propriété exclusive de l’objet enveloppé via std::move. Il rejette un pointeur nul en lançant std::invalid_argument. Il copie les caractères de Style sans conserver de référence. text() délègue à l’objet enveloppé et ajoute des crochets. On peut imbriquer les décorateurs, et leur ordre peut changer le résultat. Le destructeur virtuel de Message permet à std::unique_ptr<Message> muni du mécanisme de suppression par défaut de détruire correctement un objet dérivé.
Exemples
#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';
}
Résultat
true brief [full]
Lignes attendues : `true` confirme qu’il s’agit de la même instance, `brief` est le résultat du produit non décoré et `[full]` celui de la seconde implémentation après décoration.
Leçons associées
- C++ · Leçon 55 · Intermédiaire · Version : 2
Sources
- 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]