Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Macchine a stati finiti

Una macchina a stati finiti (FSM) descrive un comportamento usando un insieme finito di stati e transizioni attivate da eventi. In C++, `enum class` e una funzione di transizione rappresentano il modello rendendo esplicita ogni regola per lo stato successivo.

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

Sintassi

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

Una macchina a stati finiti (finite state machine, FSM) ha un insieme finito di stati, uno stato iniziale, un insieme di eventi e regole di transizione. In una macchina deterministica, ogni coppia composta dallo stato corrente e da un evento determina esattamente uno stato successivo. È un modello di progettazione, non una costruzione sintattica specifica del C++.

Nell’esempio, un tornello parte da State::locked. Event::coin lo sblocca e Event::push blocca di nuovo un tornello sbloccato. Spingere un tornello bloccato e inserire una moneta quando è sbloccato non cambiano lo stato: sono transizioni allo stesso stato definite esplicitamente. La funzione transition calcola lo stato successivo senza effetti collaterali; main memorizza e stampa il risultato.

enum class crea tipi distinti per stati ed eventi. switch seleziona un ramo in base allo stato; ogni ramo termina con return, quindi l’esecuzione non prosegue fino all’etichetta successiva. Le regole coprono tutte e quattro le combinazioni di valori denominati, verificate con static_assert. Il return state finale non è una convalida: i valori di enumerazione creati con conversioni esplicite al di fuori dell’insieme denominato non rientrano in questo modello e richiedono un controllo separato al confine dell’input.

Quando estendi la macchina, definisci il comportamento di ogni coppia stato/evento: transizione, permanenza nello stato oppure errore esplicito. Verifica anche sequenze di eventi, non solo transizioni singole. L’esempio è destinato alla compilazione con C++23; la fonte citata è una bozza di lavoro in evoluzione, non una pubblicazione C++23 immutabile.

Esempi

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

Risultato

locked
unlocked
unlocked
locked

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti