Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Končni avtomati

Končni avtomat (FSM) opisuje vedenje s končno množico stanj in prehodi, ki jih sprožijo dogodki. V C++ lahko model predstavimo z `enum class` in funkcijo prehoda, ki izrecno določi vsako pravilo za naslednje stanje.

Različica: C++23; repository compiler flag, production runtime not attested

Sintaksa

enum class State { locked, unlocked };
enum class Event { coin, push };
constexpr State transition(State state, Event event);

Končni avtomat (finite state machine, FSM) ima končno množico stanj, začetno stanje, množico dogodkov in pravila prehodov. V determinističnem avtomatu vsak par trenutnega stanja in dogodka določi natanko eno naslednje stanje. To je vzorec za modeliranje, ne posebna skladenjska konstrukcija jezika C++.

V primeru je vrtljiva zapora za prehod oseb sprva v stanju State::locked. Dogodek Event::coin jo odklene, Event::push pa odklenjeno zaporo znova zaklene. Potisk zaklenjene zapore in vstavljanje kovanca, ko je zapora odklenjena, ne spremenita stanja: to sta izrecno določena prehoda v isto stanje. Funkcija transition izračuna naslednje stanje brez stranskih učinkov; main rezultat shrani in izpiše.

enum class ustvari ločena tipa za stanja in dogodke. switch izbere vejo glede na stanje; vsaka veja se konča z return, zato se izvajanje ne nadaljuje do naslednje oznake. Pravila zajemajo vse štiri kombinacije poimenovanih vrednosti, kar preverijo stavki static_assert. Končni return state ni preverjanje veljavnosti: vrednosti naštevalnega tipa, ustvarjene z izrecnimi pretvorbami zunaj poimenovane množice, niso del tega modela in jih je treba posebej preveriti na vhodni meji.

Pri razširjanju avtomata določi pomen vsakega para stanje/dogodek: prehod, ostanek v stanju ali izrecno napako. Preizkusi tudi zaporedja dogodkov, ne le posameznih prehodov. Primer je namenjen prevajanju s C++23; navedeni vir je razvijajoči se delovni osnutek, ne nespremenljiva objava C++23.

Primeri

#include <iostream>

enum class State { locked, unlocked };
enum class Event { coin, push };

constexpr State transition(State state, Event event) {
    switch (state) {
    case State::locked:
        return event == Event::coin ? State::unlocked : State::locked;
    case State::unlocked:
        return event == Event::push ? State::locked : State::unlocked;
    }
    return state;
}

static_assert(transition(State::locked, Event::coin) == State::unlocked);
static_assert(transition(State::locked, Event::push) == State::locked);
static_assert(transition(State::unlocked, Event::coin) == State::unlocked);
static_assert(transition(State::unlocked, Event::push) == State::locked);

int main() {
    State state = State::locked;
    constexpr Event events[] = {
        Event::push, Event::coin, Event::coin, Event::push
    };
    for (Event event : events) {
        state = transition(state, event);
        std::cout << (state == State::locked ? "locked" : "unlocked") << '\n';
    }
}

Rezultat

locked
unlocked
unlocked
locked

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.

Viri