View difference between Paste ID: Kba8Fn13 and Xb0F9eg8

 #include <cstdlib>
 #include <iostream>
 
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
 
 #define STATE_AMOUNT 5
-enum State {
+
 using namespace std;
 
 enum State
 {
 	Off,
 	Stopped,
 	Walking,
 	Running,
 	Error
-class state_interface {			/* Abstract Class */
+
 
 /** The interface of the different states */
 
 class state_interface					/* Abstract Class */
 {
 	public:
 	virtual State turnOn () = 0;
 	virtual State turnOff () = 0;
-class off_State: public state_interface {
+
 	virtual State speedDown () = 0;
 };
 
 /** The different states */
 class off_State: public state_interface
 {
 	public:
 	State turnOn () {
 		cout << "Off --[turnOn]--> Stopped \n";
 		return Stopped;
-		cout << "Off --[speedUp]--> Off \n";
+
 	State turnOff () {
 		cout << "Off --[turnOff]--> Off \n";
 		return Off;
-		cout << "Off --[speedDown]--> Off \n";
+
 	State speedUp () {
 		cout << "Off --[speedUp]--> Error \n";
 		return Error;
 	};
-class stopped_State: public state_interface {
+
 		cout << "Off --[speedDown]--> Error \n";
 		return Error;
-		cout << "Stopped --[turnOn]--> Stopped \n";
+
 };
 
 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;
-class walking_State: public state_interface {
+
 	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";
-class running_State: public state_interface {
+
 	};
 	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 () {
-class error_State: public state_interface {
+
 		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 () {
-class FSM {			/* Singleton */
+
 		return Error;
 	};
 	State speedDown () {
 		cout << "Error --[speedDown]--> Error \n";
-	void initialize () {
+
 	};
 };
 
 
 class FSM						/* Singleton */
 {
 	private:
 	state_interface * current;
-	void cleanUp () {
+
 	public:
-		i = 0;
+	FSM()
-		for (i; i<STATE_AMOUNT; i++) {
+	{
 		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 () {
+
 
 	void cleanUp ()
-		while (input != 4) {
+	{
 		int i;
 
 		for (i=0; i<STATE_AMOUNT; i++)
-			switch(input){
+		{
 			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;
-int main (void) {
+
 					new_state = current -> speedUp();
-	FSM * the_machine;
+
 					break;
-	the_machine = new (FSM);
+
 					new_state = current -> speedDown();
-	the_machine -> initialize();
+
-	the_machine -> live();
+
-	the_machine -> cleanUp();
+				case(4):
 					cleanUp ();
-	delete (the_machine);
+
 				default:
-	return 0;
+
 			}
 
 		}
 	};
 };
 
 int main(int argc, char** argv)
 {
 	FSM the_machine;
 	the_machine.live();
 	return EXIT_SUCCESS;
 }