Design patterns
Monostate

Anmärkningar

Monostatmönstret

Monostate kallas vanligtvis syntaktiskt socker över Singleton mönstret eller som ett konceptuellt Singleton .

Det undviker alla komplikationer av att ha en enda instans av en klass, men alla instanser använder samma data.
Detta åstadkoms mestadels genom att använda medlemmar av static data.
En av de viktigaste funktionerna är att den är helt transparent för användarna, som inte är helt medvetna om att de arbetar med en Monostate . Användare kan skapa så många fall av en Monostate som de vill och varje instans är bra som en annan för att få åtkomst till data.

Klassen Monostate kommer vanligtvis med en ledsagarklass som används för att uppdatera inställningarna vid behov.

Det följer ett minimalt exempel på en Monostate i 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; }
};

Här är ett exempel på en enkel implementering av en Monostate i 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;
    }
}

Monostate-baserade hierarkier

I motsats till Singleton är Monostate lämplig att ärva för att förlänga dess funktionalitet, så länge medlemsmetoder inte är static .
Det följer ett minimalt exempel i 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; }
};