Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Konačni automati

Konačni automat (FSM) opisuje ponašanje pomoću konačnog skupa stanja i prijelaza koje pokreću događaji. U C++ model se može prikazati pomoću `enum class` i funkcije prijelaza koja izričito određuje svako pravilo za sljedeće stanje.

Verzija: 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);

Konačni automat (finite state machine, FSM) ima konačan skup stanja, početno stanje, skup događaja i pravila prijelaza. U determinističkom automatu svaki par trenutačnog stanja i događaja određuje točno jedno sljedeće stanje. Riječ je o obrascu modeliranja, a ne o posebnoj sintaktičkoj konstrukciji jezika C++.

U primjeru se okretište pokreće u stanju State::locked. Događaj Event::coin otključava ga, a Event::push ponovno zaključava otključano okretište. Guranje zaključanog okretišta i ubacivanje novčića dok je otključano ne mijenjaju stanje: to su izričito definirani prijelazi u isto stanje. Funkcija transition izračunava sljedeće stanje bez nuspojava; main pohranjuje i ispisuje rezultat.

enum class stvara zasebne tipove za stanja i događaje. switch odabire granu prema stanju; svaka grana završava naredbom return, pa se izvođenje ne nastavlja na sljedeću oznaku. Pravila obuhvaćaju sve četiri kombinacije imenovanih vrijednosti, što provjeravaju naredbe static_assert. Završni return state nije provjera valjanosti: vrijednosti enumeracije nastale izričitim pretvorbama izvan imenovanog skupa nisu obuhvaćene ovim modelom i zahtijevaju zasebnu provjeru na granici ulaza.

Pri proširivanju automata odredi značenje svakog para stanje/događaj: prijelaz, ostanak u stanju ili izričita pogreška. Testiraj i nizove događaja, a ne samo pojedinačne prijelaze. Primjer je namijenjen kompiliranju uz C++23; navedeni izvor razvojni je radni nacrt, a ne nepromjenjiva objava C++23.

Primjeri

#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

Prikazani kôd i navedeni rezultat provjereni su u izoliranom okruženju metodom zabilježenom u dokazu provjere za ovu točnu verziju.

Izvori