有限状态机FSM详解及其实现

最新推荐文章于 2024-07-05 11:50:53 发布
最新推荐文章于 2024-07-05 11:50:53 发布
阅读量2.3k 收藏 7
点赞数
分类专栏： 设计模式

有限状态机,也称为 FSM(Finite State Machine) ，其在任意时刻都处于有限状态集合中的某一状态。当其获得一个输入字符 时，将从 当前状态 转换到 另一个状态 ，或者仍然保持在当前状态 。任何一个FSM都可以用状态转换图来描述，图中的节点表示FSM中的一个状态，有向加权边表示输入字符时状态的变化。如果图中不存在与当前状态与输入字符对应的有向边，则FSM将进入“消亡状态 (Doom State) ”，此后FSM将一直保持“消亡状态”。状态转换图中还有两个特殊状态：状态1称为 “起始状态” ，表示FSM的初始状态。状态6称为 “结束状态” ，表示成功识别了所输入的字符序列。

在启动一个FSM时，首先必须将FSM置于“起始状态”，然后输入一系列字符，最终，FSM会到达“结束状态”或者“消亡状态”。


说明：

在通常的FSM模型中，一般还存在一个“接受状态”，并且FSM可以从“接受状态”转换到另一个状态，只有在识别最后一个字符后，才会根据最终状态来决定是否接受所输入的字符串。此外，也可以将“其实状态”也作为接受状态，因此空的输入序列也是可以接受的。

FSM的实现

程序设计思路大致如下：

  • 使用状态转换图描述FSM
  • 状态转换图中的结点对应不同的状态对象
  • 每个状态对象通过一个输入字符转换到另一个状态上，或者保持原状态不变。

通过输入字符从一个状态切换到另一个状态的过程，我们称之为一个 映射 。在计算机程序设计中， 我们可以有两种表示映射的方法：

  • 通过算法表示，即“可执行代码（Executable Code）”方式
  • 通过一张映射表，即“被动数据（Passive Data）”方式
如下详细介绍这两种实现方式：
  • 通过Executable Code 实现映射的FSM ：

这种方式主要是通过条件分支来处理不同的字符，如if或者switch语句块，如

State* State1::Transition(char c)
{
    switch(c)
    {
    case 'A':
        return &s2;
    case 'B':
        return &s3;
    case 'C':
        return &s4;
    case 'D':
        return &s5;
    case '\0':
        return NULL;
    default:
        return NULL;
    }
}


// fsm_with_executable_code.h
#ifndef FSM_WITH_EXECUTABLE_CODE_H
#define FSM_WITH_EXECUTABLE_CODE_H

#include <string.h>

class State
{
public:
    virtual State* Transition(char c) = 0;
};

class Fsm
{
public:
    Fsm();
    void Reset();            // move to start state
    void Advance(char c);    // advance one transition
    int EndState();
    int DoomState();

private:
    State* p_current;   // &s1, &s2, ..., &s6; NULL ==> doom
};


class State1 : public State
{
public:
    State* Transition(char c);
};

class State2 : public State
{
public:
    State* Transition(char c);
};

class State3 : public State
{
public:
    State* Transition(char c);
};

class State4 : public State
{
public:
    State* Transition(char c);
};

class State5 : public State
{
public:
    State* Transition(char c);
};

class State6 : public State
{
public:
    State* Transition(char c);
};

#endif // FSM_WITH_EXECUTABLE_CODE_H

// fsm_with_executable_code.cc
#include "fsm_with_executable_code.h"

State1 s1;
State2 s2;
State3 s3;
State4 s4;
State5 s5;
State6 s6;

Fsm::Fsm()
{
    p_current = NULL;
}

void Fsm::Reset()
{
    p_current = &s1;
}

void Fsm::Advance(char c)
{
    if (p_current != NULL)
        p_current = p_current->Transition(c);
}

int Fsm::EndState()
{
    return p_current == &s6;
}

int Fsm::DoomState()
{
    return p_current == NULL;
}
State* State1::Transition(char c)
{
    switch(c)
    {
    case 'A':
        return &s2;
    case 'B':
        return &s3;
    case 'C':
        return &s4;
    case 'D':
        return &s5;
    case '\0':
        return NULL;
    default:
        return NULL;
    }
}

State* State2::Transition(char c)
{
    switch(c)
    {
    case 'E':
        return &s2;
    case 'I':
        return &s6;
    case '\0':
        return NULL;
    default:
        return NULL;
    }
}

State* State3::Transition(char c)
{
    switch(c)
    {
    case 'F':
        return &s3;
    case 'M':
        return &s4;
    case 'J':
        return &s6;
    case '\0':
        return NULL;
    default:
        return NULL;
    }
}

State* State4::Transition(char c)
{
    switch(c)
    {
    case 'G':
        return &s4;
    case 'K':
        return &s6;
    case '\0':
        return NULL;
    default:
        return NULL;
    }
}

State* State5::Transition(char c)
{
    switch(c)
    {
    case 'O':
        return &s2;
    case 'H':
        return &s5;
    case 'L':
        return &s6;
    case 'N':
        return &s4;
    case '\0':
        return NULL;
    default:
        return NULL;
    }
}

State* State6::Transition(char c)
{
    return NULL;
}

// test_with_executable_code.cc
#include "fsm_with_executable_code.h"

#include "stdio.h"  // printf, scanf
#include "stdlib.h" // system

void test_fsm()
{
    char input_string[80];
    printf("Enter input expression: ");
    scanf("%s", input_string);

    Fsm fsm;
    fsm.Reset();
    int index = 0;
    fsm.Advance(input_string[index++]);

    while (!fsm.EndState() && !fsm.DoomState())
        fsm.Advance(input_string[index++]);

    if (fsm.EndState())
        printf("\nValid input expression");
    else
        printf("\nInvalid input expression");
}

int main()
{
    test_fsm();

    system("pause");
}

  •   通过Passive Data 实现映射的FSM ：

在如上的switch分支中，其使用类型大致相同，因此，我们可以考虑将相似的信息保存到一张表中，这样就可以在程序中避免很多函数调用。在每个状态中都使用一张转换表来表示映射关系，转换表的索引使用输入字符来表示。此外，由于通过转换表就可以描述不同状态之间的变化，那么就没有必要将每种状态定义为一个类了，即不需要多余的继承和虚函数了，仅使用一个State即可。

#include <limits.h>

class State
{
public:
    State();
    State* transition[range];
};

对于任意一个状态state和输入字符c，后续状态都可以通过state.transition[c]来确定。

类Fsm中的成员state包含6个状态，为了对应方便，我们将结束状态放在state[0]中，每个状态都使用一个三元组 { 当前状态，输入字符，下一个状态 } 来表示：

struct TransGraph   // use triple to describe map
{
    int current_state;
    char input_char;
    int next_state;
};
如此，使用了转换表代替了虚函数，简化了程序的设计。 
// fsm_with_passive_data.h
#ifndef FSM_WITH_PASSIVE_DATA_H
#define FSM_WITH_PASSIVE_DATA_H

#include <string.h>
#include <limits.h>     // CHAR_MAX

const int range = CHAR_MAX + 1;

class State
{
public:
    State();
    State* transition[range];
};

struct TransGraph   // use triple to describe map
{
    int current_state;
    char input_char;
    int next_state;
};

class Fsm
{
public:
    Fsm();
    void Reset();            // move to start state
    void Advance(char c);    // advance one transition
    int EndState();
    int DoomState();

private:
    State* p_current;   // &s1, &s2, ..., &s6; NULL ==> doom
    State state[6];     // 6 states, state[0] is end state
};


#endif // FSM_WITH_PASSIVE_DATA_H

// fsm_with_passive_data.cc
#include "fsm_with_passive_data.h"

State::State()
{
    for (int i = 0; i < range; ++i)
        transition[i] = NULL;
}

Fsm::Fsm()
{
    static TransGraph graph[] =
    {
        {1, 'A', 2}, {1, 'B', 3}, {1, 'C', 4}, {1, 'D', 5},
        {2, 'E', 2}, {2, 'I', 0},
        {3, 'F', 3}, {3, 'J', 0}, {3, 'M', 4},
        {4, 'G', 4}, {4, 'K', 0},
        {5, 'H', 5}, {5, 'L', 0}, {5, 'O', 2}, {5, 'N', 4},
        {0, 0, 0}
    };

    for (TransGraph* p_tg = graph; p_tg->current_state != 0; ++p_tg)
        state[p_tg->current_state].transition[p_tg->input_char] = &state[p_tg->next_state];

    p_current = NULL;
}

void Fsm::Reset()
{
    p_current = &state[1];
}

void Fsm::Advance(char c)
{
    if (p_current != NULL)
        p_current = p_current->transition[c];
}

int Fsm::EndState()
{
    return p_current == &state[0];
}

int Fsm::DoomState()
{
    return p_current == NULL;
}

// test_with_passive_data.cc
#include "fsm_with_passive_data.h"

#include "stdio.h"  // printf, scanf
#include "stdlib.h" // system

void test_fsm()
{
    char input_string[80];
    printf("Enter input expression: ");
    scanf("%s", input_string);

    Fsm fsm;
    fsm.Reset();
    int index = 0;
    fsm.Advance(input_string[index++]);

    while (!fsm.EndState() && !fsm.DoomState())
        fsm.Advance(input_string[index++]);

    if (fsm.EndState())
        printf("\nValid input expression");
    else
        printf("\nInvalid input expression");
}


int main()
{
    test_fsm();

    system("pause");
}

通用FSM的设计

如果类Fsm可以表示任意类型的FSM，那么就更符合程序设计的要求了。在构造函数中执行的具体配置应该被泛化为一种机制，我们通过这种机制来建立任意的FSM。在Fsm的构造函数中，应该将转换表作为一个参数传入，而非包含具体的转换表，如此，则不需要将转换表的大小硬编码到Fsm中了。因此，在构造函数中必须动态地创建这个存放转换表的内存空间，在析构函数中记着销毁这块内存。

class Fsm
{
public:
    Fsm(TransGraph* p_tg);
    virtual ~Fsm();
    void Reset();
    void Advance(char c);
    int EndState();
    int DoomState();

private:
    State* p_current;
    State* p_state;
};

Fsm::Fsm(TransGraph* p_tg)
{
    int max_state = 0;  // size for dynamically allocated graph
    for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)
    {
        if (p_temp->current_state > max_state)
            max_state = p_temp->current_state;
        if (p_temp->next_state > max_state)
            max_state = p_temp->next_state;
    }

    p_state = new State[max_state + 1];
    for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)
        p_state[p_temp->current_state].transition[p_temp->input_char] = &p_state[p_temp->next_state];

    p_current = NULL;
}

Fsm::~Fsm()
{
    delete []p_state;
}

// fsm_with_generalization.h
#ifndef FSM_WITH_GENERALIZATION_H
#define FSM_WITH_GENERALIZATION_H

#include <string.h>
#include <limits.h>     // CHAR_MAX

const int range = CHAR_MAX + 1;

class State
{
public:
    State();
    State* transition[range];
};

struct TransGraph
{
    int current_state;
    char input_char;
    int next_state;
};

class Fsm
{
public:
    Fsm(TransGraph* p_tg);
    virtual ~Fsm();
    void Reset();
    void Advance(char c);
    int EndState();
    int DoomState();

private:
    State* p_current;
    State* p_state;
};


#endif // FSM_WITH_GENERALIZATION_H

// fsm_with_generalization.cc
#include "fsm_with_generalization.h"

State::State()
{
    for (int i = 0; i < range; ++i)
        transition[i] = NULL;
}

Fsm::Fsm(TransGraph* p_tg)
{
    int max_state = 0;  // size for dynamically allocated graph
    for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)
    {
        if (p_temp->current_state > max_state)
            max_state = p_temp->current_state;
        if (p_temp->next_state > max_state)
            max_state = p_temp->next_state;
    }

    p_state = new State[max_state + 1];
    for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)
        p_state[p_temp->current_state].transition[p_temp->input_char] = &p_state[p_temp->next_state];

    p_current = NULL;
}

Fsm::~Fsm()
{
    delete []p_state;
}

void Fsm::Reset()
{
    p_current = &p_state[1];
}

void Fsm::Advance(char c)
{
    if (p_current != NULL)
        p_current = p_current->transition[c];
}

int Fsm::EndState()
{
    return p_current == &p_state[0];
}

int Fsm::DoomState()
{
    return p_current == NULL;
}

// test_with_generalization.cc
#include "fsm_with_generalization.h"

#include "stdio.h"  // printf, scanf
#include "stdlib.h" // system

void test_fsm()
{
    char input_string[80];
    printf("Enter input expression: ");
    scanf("%s", input_string);

    TransGraph graph[] =
    {
        {1, 'A', 2}, {1, 'B', 3}, {1, 'C', 4}, {1, 'D', 5},
        {2, 'E', 2}, {2, 'I', 0},
        {3, 'F', 3}, {3, 'J', 0}, {3, 'M', 4},
        {4, 'G', 4}, {4, 'K', 0},
        {5, 'H', 5}, {5, 'L', 0}, {5, 'O', 2}, {5, 'N', 4},
        {0, 0, 0}
    };

    Fsm fsm(graph);
    fsm.Reset();
    int index = 0;
    fsm.Advance(input_string[index++]);

    while (!fsm.EndState() && !fsm.DoomState())
        fsm.Advance(input_string[index++]);

    if (fsm.EndState())
        printf("\nValid input expression");
    else
        printf("\nInvalid input expression");
}


int main()
{
    test_fsm();

    system("pause");
}

当然也可以将上述程序中的转换表不放在主程序中，而是由一个派生自Fsm的子类SpecificFsm提供，在SpecificFsm中设置具体的转换表，然后通过SpecificFsm的初始化列表传到基类Fsm中，这样在主程序中就可以使用SpecificFsm来进行操作了。


原文：http://www.cnblogs.com/benxintuzi/p/4931258.html

Nirvana__
关注
专栏目录
GameFramework框架详解之 Fsm状态机
TxNet
03-27 1979
FSM（有限状态机）是一种在游戏编程中非常常用的编程技术，可以方便地管理游戏中的各种状态转换。在Gameframework中，FSM也被广泛使用，并且该框架提供了方便易用的FSM API，使得我们可以在Unity项目中快速实现FSM逻辑。有限状态机（Finite-state machine,FSM），又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。
有限状态机FSM详解（三）
benjonc的博客
04-11 1450
这篇讲解如何使用第二篇中写好的类。我们使用的是游戏角色的移动、跳跃、攻击、待机四个状态来讲，那么我们要构建出这四个状态，需要设计的模型是什么呢？需要设计一个角色类、一个驱动角色实例的运行环境&lt;Unity的MonoBehaviour就行了&gt;。那我们设计角色类，角色类中持有四个状态类的实例、一个状态机实例。首先是四个状态类：    移动状态类(继承State类)        移动状态类中...
有限状态机 java 开源_开源可视化有限状态机编辑器
weixin_42502503的博客
02-13 338
用过Unity开发的工程师们一定对Mecanim的方便快捷印象深刻，用过之后再也不想回到刀耕火种的时代了。目前在做egret项目，首先就动手做了一个仿制Mecanim的FSM编辑器。工具做得越早，受益越多。简要说明：State：状态。成员变量中包含Transition数组。Transition：状态跳转。成员变量包含from(初始状态)和to(跳转状态)，以及condition数组。Conditi...
有限状态机的定义及相关示例
最新发布
永乐的博客
07-05 924
有限状态机（Finite State Machine, FSM）是一种数学模型，用于描述一个系统在不同状态下对外部事件的响应方式。它由一组有限的状态、一个初始状态、一个或多个终态（可选）以及一组状态之间的转移规则构成
FSM有限状态机的使用
weixin_42593278的博客
04-13 594
FSM F（finite）：有限的 S（state）：状态 M（Machine）：机械 FSM（有限状态机）：指在任意时刻都处于有限状态集合中的某一状态 我们在wiki.unity3d.com中搜索state 选择第二个，17kb大小的。打开以后，上边是源码，下边是案例。 我们复制上边的源码到我们的项目中，根据不同的需求，开始编写我们所需要的状态 FSMState类：这个类表示有限状...
FSM（有限状态机）
SjiaM的博客
05-11 1万+
本文介绍FSM（有限状态机），以及如何引用、解决问题案例
有限状态机FSM详解（一）
benjonc的博客
04-09 5万+
有限状态机在维基百科中的解释是： 有限状态机（英语：finite-state machine，缩写：FSM）又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 至于为什么要学FSM，FSM可以把模型的多状态、多状态间的转换条件解耦。可以使维护变得容易，代码也更加具有可读性，也更加艺术。 理解有限状态机首先需要理解整个模型。我们把灯的开关作为示例，...
有限状态机FSM详解（二）
benjonc的博客
04-11 2199
第一篇写好了接口，这篇来写具体实现。首先是State类，他要实现IState接口： public class JyState : IState { public string Name { get { return _name; } } public string Tag { get { return _tag; } ...
有限状态机FSM详解（四）
benjonc的博客
04-11 1025
这篇接上篇给出整个代码和使用案例。角色类：public class Player { private JyStateMachine FSM; private MoveState _move; private JumpState _jump; private AttackState _attack; privat...
有限状态机FSM
09-19
Unity C# 《有限状态机》的用法教程详解Demo 助力快速理解 FSM 有限状态机，完成游戏状态的切换 教程地址：https://blog.csdn.net/ChinarCSDN/article/details/82263126
【有限状态机】- FSM详细讲解 【附Autoware有限状态机模型代码讲解】
BigDavid123的博客
03-27 2493
本文详细介绍了有限状态机的三种实现方式：分支、状态模式、查表法
【FPGA/IC】状态机FSM的各种写法（一段式、二段式、三段式、摩尔型Moore、米勒型Mealy）
热门推荐
孤独的单刀
08-05 5万+
FPGA状态机（一段式、二段式、三段式）、摩尔型（Moore）和米勒型（Mealy）
状态机(有限状态自动机 FSM)介绍以及常用状态机种类对比
黄嚯嚯
10-20 7752
状态机概念, 为什么要使用状态机
什么是状态机（FSM）？
weixin_49007164的博客
06-07 529
FSM 的核心组成部分包括状态、状态之间的转移、输入、输出和转移条件。状态代表了系统在某一时间点的特定状态，而状态之间的转移则描述了系统如何根据输入和当前状态从一个状态转移到另一个状态。FSM 通过定义系统在特定时间的状态、状态之间的转移、以及引起这些转移的条件来描述系统的运行过程。它广泛应用于计算机科学、电子工程、控制理论等领域，用于设计硬件电路、解析输入串、控制逻辑、协议设计等。有限状态机是一种用于设计和分析系统行为的强大工具，通过明确的状态、输入、输出和状态转移来描述系统的行为。
FPGA FSM有限状态机
qq_45151652的博客
04-16 167
有限状态机是系统的数学抽象，它可以在给定时间恰好处于有限状态之一，并且可以使用适当的输入信号将状态从一个状态更改为另一个状态（状态转换）。状态是对系统状态的描述，该系统正在等待某个触发器来执行从一个状态到另一个状态的转换。设计的 FSM 的状态图如图 3 所示。应该注意的是，我们将为未声明的状态、转换或输入信号添加额外的 ERR_STATE（参见下面的 Verilog 代码）。有两种流行的 FSM 实现：Moore FSM（输出仅取决于当前状态）和 Mealy FSM（输出取决于当前状态和输入信号）。
ASIC-WORLD Verilog（13）状态机FSM
孤独的单刀
08-28 1286
ASIC-WORLD Verilog（13）状态机FSM
关于有限状态机（FSM）
m0_58427556的博客
12-15 406
英文名为Finite State Machine，指的是在有限个状态之间按照一定规律进行转换的电路。
C++实现有限状态机FSM详解
在实际编程中，实现有限状态机有两种主要方法：状态转移图和状态转移表。状态转移图以图形化的方式直观地表示各个状态和它们之间的转移，每个节点代表一个状态，边则表示状态间的转移，通常标有触发转移的事件。状态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值