Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Máquinas de estados finitos

Una máquina de estados finitos (FSM) describe un comportamiento mediante un conjunto finito de estados y transiciones activadas por eventos. En C++, `enum class` y una función de transición permiten representar el modelo y hacer explícita cada regla para el siguiente estado.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

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

Una máquina de estados finitos (finite state machine, FSM) tiene un conjunto finito de estados, un estado inicial, un conjunto de eventos y reglas de transición. En una máquina determinista, cada par formado por el estado actual y un evento determina exactamente un estado siguiente. Es un patrón de modelado, no una construcción sintáctica propia de C++.

En el ejemplo, un torniquete empieza en State::locked. Event::coin lo desbloquea y Event::push vuelve a bloquear un torniquete desbloqueado. Empujar un torniquete bloqueado e introducir una moneda cuando está desbloqueado no cambian el estado: son transiciones al mismo estado definidas explícitamente. La función transition calcula el siguiente estado sin efectos secundarios; main guarda e imprime el resultado.

enum class crea tipos distintos para estados y eventos. switch selecciona una rama según el estado; cada rama termina con return, así que la ejecución no continúa hasta la etiqueta siguiente. Las reglas cubren las cuatro combinaciones de valores con nombre, comprobadas mediante static_assert. El return state final no es una validación: los valores de enumeración creados mediante conversiones explícitas fuera del conjunto con nombre no forman parte de este modelo y requieren una comprobación aparte en el límite de entrada.

Al ampliar la máquina, define qué significa cada par de estado y evento: una transición, permanecer en el estado o un error explícito. Prueba también secuencias de eventos, no solo transiciones individuales. El ejemplo está pensado para compilarse con C++23; la fuente citada es un borrador de trabajo en evolución, no una publicación inmutable de C++23.

Ejemplos

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

Resultado

locked
unlocked
unlocked
locked

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes