Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Automaty skończone

Automat skończony (FSM) opisuje zachowanie za pomocą skończonego zbioru stanów i przejść wywoływanych zdarzeniami. W C++ można go zapisać przy użyciu enum class oraz funkcji przejścia, która jawnie określa następny stan.

Wersja: C++23; repository compiler flag, production runtime not attested

Składnia

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

Automat skończony (finite state machine, FSM) ma skończony zbiór stanów, stan początkowy, zbiór zdarzeń i reguły przejść. W wersji deterministycznej każda para bieżącego stanu i zdarzenia wyznacza dokładnie jeden następny stan. Jest to wzorzec modelowania, a nie osobna konstrukcja składniowa C++.

W przykładzie bramka zaczyna w State::locked. Zdarzenie Event::coin ją odblokowuje, a Event::push ponownie blokuje odblokowaną bramkę. Naciśnięcie zablokowanej bramki oraz wrzucenie monety do odblokowanej bramki pozostawiają stan bez zmian: są to jawnie zdefiniowane przejścia do tego samego stanu. Funkcja transition oblicza następny stan bez efektów ubocznych; main zapisuje wynik i go wypisuje.

enum class tworzy odrębne typy stanów i zdarzeń. switch wybiera gałąź według stanu; każda gałąź kończy się przez return, więc wykonanie nie przechodzi do kolejnej etykiety. Reguły obejmują wszystkie cztery kombinacje nazwanych wartości, co sprawdzają instrukcje static_assert. Końcowe return state nie jest walidacją: wartości wyliczeń utworzone przez jawne rzutowania spoza nazwanego zbioru nie są objęte modelem i na granicy wejścia wymagają osobnej kontroli.

Przy rozbudowie automatu określ zachowanie każdej pary stanu i zdarzenia: przejście, pozostanie w stanie albo jawny błąd. Testuj także sekwencje zdarzeń, nie tylko pojedyncze przejścia. Przykład jest przeznaczony do kompilacji w trybie C++23; wskazane źródło jest rozwijanym szkicem standardu, a nie zamrożoną publikacją C++23.

Przykłady

#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';
    }
}

Wynik

locked
unlocked
unlocked
locked

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła