：狀態模式：GumballMachine

#ifndef __STATE_H__
#define __STATE_H__

#include <iostream>
#include<stdlib.h>
using namespace std;
class GumballMachine;

class State
{
public:
	State();
	virtual ~State();
	virtual void insertQuarter();
	virtual void ejectQuarter();
	virtual void turnCrank();
	virtual void dispense();
};

class NoQuarterState : public State
{
private:
	GumballMachine *gumballmachine;
public:
	NoQuarterState(GumballMachine *g);
	virtual ~NoQuarterState();
	virtual void insertQuarter();
	virtual void ejectQuarter();
	virtual void turnCrank();
	virtual void dispense();

};

class SoldOutState :public State
{
private:
	GumballMachine *gumballmachine;
public:
	SoldOutState(GumballMachine *g);
	virtual ~SoldOutState();
	virtual void insertQuarter();
	virtual void ejectQuarter();
	virtual void turnCrank();
	virtual void dispense();
};

class HasQuarterState :public State
{
private:
	GumballMachine *gumballmachine;
public:
	HasQuarterState(GumballMachine *g);
	virtual ~HasQuarterState();
	virtual void insertQuarter();
	virtual void ejectQuarter();
	virtual void turnCrank();
	virtual void dispense();
};

class SoldState :public State
{
private:
	GumballMachine *gumballmachine;
public:
	SoldState(GumballMachine *g);
	virtual ~SoldState();
	virtual void insertQuarter();
	virtual void ejectQuarter();
	virtual void turnCrank();
	virtual void dispense();
};


class WinnerState :public State
{
private:
	GumballMachine *gumballmachine;
public:
	WinnerState(GumballMachine *g);
	virtual ~WinnerState();
	virtual void insertQuarter();
	virtual void ejectQuarter();
	virtual void turnCrank();
	virtual void dispense();
};


#endif

#include "State.h"
#include "GumballMachine.h"
void State::dispense()
{

}

void State::turnCrank()
{

}

void State::ejectQuarter()
{

}

void State::insertQuarter()
{

}

State::~State()
{

}

State::State()
{

}
NoQuarterState::~NoQuarterState()
{

}

NoQuarterState::NoQuarterState(GumballMachine *g)
{
	gumballmachine = g;
}

void NoQuarterState::dispense()
{
	cout << "You need to pay first." << endl;
}

void NoQuarterState::turnCrank()
{
	cout << "You turned, but there is no quarter." << endl;
}

void NoQuarterState::ejectQuarter()
{
	cout << "You has not insert quarter." << endl;
}

void NoQuarterState::insertQuarter()
{
	cout << "You insert a quarter." << endl;
	gumballmachine->SetState(gumballmachine->GetHasQuarterState());
}


void SoldOutState::dispense()
{
	cout << "Sold out." << endl;
}

void SoldOutState::turnCrank()
{
	cout << "Sold out, there is no quarter." << endl;
}

void SoldOutState::ejectQuarter()
{
	cout << "Sold out, can't eject quarter." << endl;
}

void SoldOutState::insertQuarter()
{
	cout << "Sold out, You can't insert a quarter." << endl;
}

SoldOutState::~SoldOutState()
{

}

SoldOutState::SoldOutState(GumballMachine *g)
{
	gumballmachine = g;
}

void HasQuarterState::dispense()
{
	cout << "No gum ball dispensed." << endl;
}

void HasQuarterState::turnCrank()
{
	cout << "You turned." << endl;
	int winner = (rand() % 10);
	if (winner == 0 && gumballmachine->getCount() > 1)
	{
		gumballmachine->SetState(gumballmachine->GetWinnerState());
	}
	else
	{
		gumballmachine->SetState(gumballmachine->GetSoldState());
	}
}

void HasQuarterState::ejectQuarter()
{
	cout << "Quarter returned." << endl;
	gumballmachine->SetState(gumballmachine->GetNoQuarterState());
}

void HasQuarterState::insertQuarter()
{
	cout << "You can't insert another quarter." << endl;
}

HasQuarterState::~HasQuarterState()
{

}

HasQuarterState::HasQuarterState(GumballMachine *g)
{
	gumballmachine = g;
}

void SoldState::dispense()
{
	gumballmachine->releaseBall();
	if (gumballmachine->getCount() > 0)
	{
		gumballmachine->SetState(gumballmachine->GetNoQuarterState());
	}
	else
	{
		cout << "Oops, out of gum balls!" << endl;
		gumballmachine->SetState(gumballmachine->GetSoldOutState());
	}
}

void SoldState::turnCrank()
{
	cout << "Turning twice does not get you another gum ball." << endl;
}

void SoldState::ejectQuarter()
{
	cout << "Sorry, you already turned the crank." << endl;
}

void SoldState::insertQuarter()
{
	cout << "Please wait, we are already giving you a gum ball." << endl;
}

SoldState::~SoldState()
{

}

SoldState::SoldState(GumballMachine *g)
{
	gumballmachine = g;
}

void WinnerState::dispense()
{
	cout << "YOU ARE A WINNER, You get two gum balls." << endl;
	gumballmachine->releaseBall();
	if (gumballmachine->getCount() == 0)
	{
		gumballmachine->SetState(gumballmachine->GetSoldOutState());
	}
	else
	{
		gumballmachine->releaseBall();
		if (gumballmachine->getCount() == 0)
		{
			gumballmachine->SetState(gumballmachine->GetSoldOutState());
		}
		else
		{
			gumballmachine->SetState(gumballmachine->GetNoQuarterState());
		}
	}
}

void WinnerState::turnCrank()
{
	cout << "Turning twice does not get you another gum ball." << endl;
}

void WinnerState::ejectQuarter()
{
	cout << "Sorry, you already turned the crank." << endl;
}

void WinnerState::insertQuarter()
{
	cout << "Please wait, we are already giving you a gum ball." << endl;
}

WinnerState::~WinnerState()
{

}

WinnerState::WinnerState(GumballMachine *g)
{
	gumballmachine = g;
}

#ifndef __GUMBALLMACHINE_H__
#define __GUMBALLMACHINE_H__
#include "State.h"
#include <iostream>
#include<stdlib.h>
using namespace std;
//class State;
class GumballMachine
{
private:
	State *soldOutState;
	State *noQuarterState;
	State *hasQuarterState;
	State *soldState;
	State *winnerState;
	State *CurrentState;
	int Count;
public:
	GumballMachine(int num);
	~GumballMachine();

	void insertQuarter();

	void ejectQuarter();

	void turnCrank();

	void SetState(State *st);

	State * GetNoQuarterState();

	State * GetWinnerState();

	State * GetHasQuarterState();

	State * GetSoldState();

	State * GetSoldOutState();
	void releaseBall();
	int getCount();
};
#endif

#include "GumballMachine.h"

int GumballMachine::getCount()
{
	return Count;
}

void GumballMachine::releaseBall()
{
	cout << "A ball comes rolling out the slot." << endl;
	if (Count != 0)
	{
		Count--;
	}
}

State * GumballMachine::GetSoldOutState()
{
	return soldOutState;
}

State * GumballMachine::GetSoldState()
{
	return soldState;
}

State * GumballMachine::GetHasQuarterState()
{
	return hasQuarterState;
}

State * GumballMachine::GetWinnerState()
{
	return winnerState;
}

State * GumballMachine::GetNoQuarterState()
{
	return noQuarterState;
}

void GumballMachine::SetState(State *st)
{
	CurrentState = st;
}

void GumballMachine::turnCrank()
{
	CurrentState->turnCrank();
	CurrentState->dispense();
}

void GumballMachine::ejectQuarter()
{
	CurrentState->ejectQuarter();
}

void GumballMachine::insertQuarter()
{
	CurrentState->insertQuarter();
}

GumballMachine::~GumballMachine()
{

}

GumballMachine::GumballMachine(int num)
{
	Count = num;
	soldOutState = new SoldOutState(this);
	noQuarterState = new NoQuarterState(this);
	hasQuarterState = new HasQuarterState(this);
	winnerState = new WinnerState(this);
	soldState = new SoldState(this);
	if (Count > 0)
	{
		CurrentState = noQuarterState;
	}
}

#include <iostream>
#include "GumballMachine.h"
using namespace std;
int main()
{
	GumballMachine *g = new GumballMachine(10);
	for (int i = 0; i < 11; i ++)
	{
		cout << "================================" << endl;
		g->insertQuarter();
		g->turnCrank();
	}
	return 0;
}