Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Machines à états finis

Une machine à états finis (FSM) décrit un comportement à l’aide d’un ensemble fini d’états et de transitions déclenchées par des événements. En C++, `enum class` et une fonction de transition permettent de représenter le modèle en explicitant chaque règle de l’état suivant.

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

Syntaxe

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

Une machine à états finis (finite state machine, FSM) possède un ensemble fini d’états, un état initial, un ensemble d’événements et des règles de transition. Dans une machine déterministe, chaque paire formée de l’état courant et d’un événement détermine exactement un état suivant. Il s’agit d’un modèle de conception, et non d’une construction syntaxique propre à C++.

Dans l’exemple, un tourniquet commence dans State::locked. Event::coin le déverrouille, et Event::push reverrouille un tourniquet déverrouillé. Pousser un tourniquet verrouillé ou insérer une pièce alors qu’il est déverrouillé ne change pas l’état : ces transitions vers le même état sont définies explicitement. La fonction transition calcule l’état suivant sans effet secondaire ; main stocke et affiche le résultat.

enum class crée des types distincts pour les états et les événements. switch sélectionne une branche en fonction de l’état ; chaque branche se termine par return, donc l’exécution ne passe pas à l’étiquette suivante. Les règles couvrent les quatre combinaisons de valeurs nommées, vérifiées par les static_assert. Le return state final n’est pas une validation : les valeurs d’énumération créées par des conversions explicites en dehors de l’ensemble nommé ne relèvent pas de ce modèle et doivent faire l’objet d’une vérification séparée à la frontière des entrées.

Lors de l’extension de la machine, définissez le comportement de chaque paire état/événement : transition, maintien dans l’état ou erreur explicite. Testez aussi des séquences d’événements, pas seulement des transitions individuelles. L’exemple vise une compilation en C++23 ; la source citée est un projet de norme en évolution, et non une publication C++23 figée.

Exemples

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

Résultat

locked
unlocked
unlocked
locked

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources