Ej5C++

#include <cstdlib>
#include <iostream>

#include "gtest/gtest.h"
#include "gmock/gmock.h"

#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 cleanUp ()
    {
        int i;

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

    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;
                case(4):
                    cleanUp ();
                    break;
                default:
                    break;
            }

        }
    };
};

int main(int argc, char** argv)
{
    FSM the_machine;
    the_machine.live();
    return EXIT_SUCCESS;
}