Design patterns
Monostate

Remarques

Le modèle de monostate

Le modèle Monostate est généralement appelé sucre syntaxique sur le modèle Singleton ou Singleton conceptuel .

Il évite toutes les complications liées à une seule instance d'une classe, mais toutes les instances utilisent les mêmes données.
Ceci est accompli principalement en utilisant static membres de données static .
L'une des caractéristiques les plus importantes est qu'il est absolument transparent pour les utilisateurs qui ignorent complètement qu'ils travaillent avec un Monostate . Les utilisateurs peuvent créer autant d'instances d'un Monostate qu'ils le souhaitent et chaque instance peut être considérée comme une autre pour accéder aux données.

La classe Monostate est généralement fournie avec une classe compagnon utilisée pour mettre à jour les paramètres si nécessaire.

Il suit un exemple minimal de Monostate en C ++:

struct Settings {
    Settings() {
        if(!initialized) {
            initialized = true;
            // load from file or db or whatever
            // otherwise, use the SettingsEditor to initialize settings
            Settings::width_ = 42;
            Settings::height_ = 128;
        }
    }

    std::size_t width() const noexcept { return width_; }
    std::size_t height() const noexcept { return height_; }

private:
    friend class SettingsEditor;

    static bool initialized;
    static std::size_t width_;
    static std::size_t height_;
};

bool Settings::initialized = false;
std::size_t Settings::width_;
std::size_t Settings::height_;

struct SettingsEditor {
    void width(std::size_t value) noexcept { Settings::width_ = value; }
    void height(std::size_t value) noexcept { Settings::height_ = value; }
};

Voici un exemple d'implémentation simple d'un Monostate en Java:

public class Monostate {
    private static int width;
    private static int height;

    public int getWidth() {
        return Monostate.width;
    }

    public int getHeight() {
        return Monostate.height;
    }

    public void setWidth(int value) {
        Monostate.width = value;
    }

    public void setHeight(int value) {
        Monostate.height = value;
    }

    static {
        width = 42;
        height = 128;
    }
}

Hiérarchies basées sur Monostate

Contrairement au Singleton , le Monostate peut être hérité pour étendre ses fonctionnalités, tant que les méthodes membres ne sont pas static .
Il suit un exemple minimal en C ++:

struct Settings {
    virtual std::size_t width() const noexcept { return width_; }
    virtual std::size_t height() const noexcept { return height_; }

private:
    static std::size_t width_;
    static std::size_t height_;
};

std::size_t Settings::width_{0};
std::size_t Settings::height_{0};

struct EnlargedSettings: Settings {
    std::size_t width() const noexcept override { return Settings::height() + 1; }
    std::size_t height() const noexcept override { return Settings::width()  + 1; }
};