Ej5C++

#include <cstdlib>
#include <iostream>

#define STATE_AMOUNT 5

using namespace std;

enum State
{
    Off,
    Stopped,
    Walking,
    Running,
    Error
};

/** The interface of the different states */

class state_interface                   /* Abstract Class */
{
    public:
    virtual State turnOn () = 0;
    virtual State turnOff () = 0;
    virtual State speedUp () = 0;
    virtual State speedDown () = 0;
};

/** The different states */
class off_State: public state_interface
{
    public:
    State turnOn () {
        cout << "Off --[turnOn]--> Stopped \n";
        return Stopped;
    };
    State turnOff () {
        cout << "Off --[turnOff]--> Off \n";
        return Off;
    };
    State speedUp () {
        cout << "Off --[speedUp]--> Error \n";
        return Error;
    };
    State speedDown () {
        cout << "Off --[speedDown]--> Error \n";
        return Error;
    };
};

class stopped_State: public state_interface
{
    public:
    State turnOn () {
        cout << "Stopped --[turnOn]--> Error \n";
        return Stopped;
    };
    State turnOff () {
        cout << "Stopped --[turnOff]--> Off \n";
        return Off;
    };
    State speedUp () {
        cout << "Stopped --[speedUp]--> Walking \n";
        return Walking;
    };
    State speedDown () {
        cout << "Stopped --[speedDown]--> Error \n";
        return Error;
    };
};

class walking_State: public state_interface
{
    public:
    State turnOn () {
        cout << "Walking --[turnOn]--> Walking \n";
        return Walking;
    };
    State turnOff () {
        cout << "Walking --[turnOff]--> Off \n";
        return Off;
    };
    State speedUp () {
        cout << "Walking --[speedUp]--> Running \n";
        return Running;
    };
    State speedDown () {
        cout << "Walking --[speedDown]--> Stopped \n";
        return Stopped;
    };
};

class running_State: public state_interface
{
    public:
    State turnOn () {
        cout << "Running --[turnOn]--> Running \n";
        return Running;
    };
    State turnOff () {
        cout << "Running --[turnOff]--> Off \n";
        return Off;
    };
    State speedUp () {
        cout << "Running --[speedUp]--> Error \n";
        return Error;
    };
    State speedDown () {
        cout << "Running --[speedDown]--> Walking \n";
        return Walking;
    };
};

class error_State: public state_interface
{
    public:
    State turnOn () {
        cout << "Error --[turnOn]--> Error \n";
        return Error;
    };
    State turnOff () {
        cout << "Error --[turnOff]--> Off \n";
        return Off;
    };
    State speedUp () {
        cout << "Error --[speedUp]--> Error \n";
        return Error;
    };
    State speedDown () {
        cout << "Error --[speedDown]--> Error \n";
        return Error;
    };
};


class FSM                       /* Singleton */
{
    private:
    state_interface * current;
    state_interface * states [STATE_AMOUNT];
    public:
    FSM()
    {
        states[Off] = new (off_State);
        states[Stopped] = new (stopped_State);
        states[Walking] = new (walking_State);
        states[Running] = new (running_State);
        states[Error] = new (error_State);
        current = states[Off];
    };

    void live ()
    {
        int input = 0;

        while (input != 4)
        {
            cout << "Input stimulus: 0_On, 1_Off, 2_SpUp, 3_SpDn, 4_Exit \n";
            cin >> input;

            switch(input)
            {
                State new_state;
                case(0):
                    new_state = current -> turnOn();
                    current = states[new_state];
                    break;
                case(1):
                    new_state = current -> turnOff();
                    current = states[new_state];
                    break;
                case(2):
                    new_state = current -> speedUp();
                    current = states[new_state];
                    break;
                case(3):
                    new_state = current -> speedDown();
                    current = states[new_state];
                    break;
                default:
                    break;
            }

        }
    };
        ~FSM(){
                int i;

                for (i=0; i<STATE_AMOUNT; i++) {
                        delete (states[i]);
                        states[i] = 0;
                }
                current = 0;
        };
};


int main (void)
{
    FSM the_machine;

    the_machine.live();

    return 0;
}