：状态模式：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;
}