状态模式

状态模式 允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

class GumballMachine;

class State {
public:
    virtual insertQuarter() {
        cout << "wrong state" << endl;
    }

    virtual ejectQuarter() {
        cout << "wrong state" << endl;
    }

    virtual turnCrank() {
        cout << "wrong state" << endl;
    }

    virtual dispense() {
        cout << "wrong state" << endl;
    }

    virtual string printInfo() = 0;
    State(GumballMachine *mgumballMachine) : gumballMachine(mgumballMachine) {}
protected:
    GumballMachine *gumballMachine;
};

class GumballMachine {
public:
    GumballMachine(int numberGumballs) {
        soldOutState = new SoldOutState(this);
        noQuarterState = new NoQuarterState(this);
        hasQuarterState = new HasQuarterState(this);
        soldState = new SoldState(this);

        this->count = numberGumballs;
         if (numberGumballs > 0) {
            state = noQuarterState;
        } else {
            state = soldOutState;
        }
    }

     ~GumballMachine() {
         delete soldOutState;
         delete noQuarterState;
         delete hasQuarterState;
         delete soldState;
    }

    void insertQuarter() {
        state->insertQuarter();
    }

    void ejectQuarter() {
        state->ejectQuarter();
    }

    void turnCrank() {
        state->turnCrank();
        state->dispense();
    }

    virtual void setState(State *state) {
        this->state = state;
    }

    virtual void releaseBall() {
        cout << "A gumball comes rolling out the slot..." << endl;
        if (count != 0) {
            count = count - 1;
        }
    }

    virtual int getCount() {
        return count;
    }

    void refill(int count) {
        this->count = count;
        state = noQuarterState;
    }

    virtual State *getState() {
        return state;
    }

    virtual State *getSoldOutState() {
        return soldOutState;
    }

    virtual State *getNoQuarterState() {
        return noQuarterState;
    }

    virtual State *getHasQuarterState() {
        return hasQuarterState;
    }

    virtual State *getSoldState() {
        return soldState;
    }

    printInfo() {
        string result;
        result.append("\nMighty Gumball, Inc.");
        result.append("\nC++-enabled Standing Gumball Model #2016");
        result.append("\nInventory: ");
        ostringstream oss;
        oss << count;
        result.append(oss.str());
        result.append(" gumball");
        if (count != 1) {
            result.append("s");
        }
        result.append("\n");
        result.append("Machine is ");
        result.append(state->printInfo());
        result.append("\n");
        cout << result << endl;
    }

private:
    State *soldOutState;
    State *noQuarterState;
    State *hasQuarterState;
    State *soldState;

    State *state;
    int count;

    class NoQuarterState : public State {
    public:
        NoQuarterState(GumballMachine *gumballMachine) :
            State(gumballMachine) {}

        virtual insertQuarter() {
            cout << "You inserted a quarter" << endl;
            gumballMachine->setState(gumballMachine->getHasQuarterState());
        }

        virtual string printInfo() {
            return "waiting for quarter";
        }
    };

    struct HasQuarterState : public State {
        HasQuarterState(GumballMachine *gumballMachine) :
            State(gumballMachine) {}

        virtual ejectQuarter() {
            cout << "Quarter returned" << endl;
            gumballMachine->setState(gumballMachine->getNoQuarterState());
        }

        virtual turnCrank() {
            cout << "You turned..." << endl;
            gumballMachine->setState(gumballMachine->getSoldState());
        }

        virtual string printInfo() {
            return "waiting for turn of crank";
        }
    };

    struct SoldState : public State {
        SoldState(GumballMachine *gumballMachine) :
            State(gumballMachine) {}

        virtual dispense() {
            gumballMachine->releaseBall();
            if (gumballMachine->getCount() > 0) {
                gumballMachine->setState(gumballMachine->getNoQuarterState());
            } else {
                cout << "Oops, out of gumballs!" << endl;
                gumballMachine->setState(gumballMachine->getSoldOutState());
            }
        }

        virtual string printInfo() {
            return "dispensing a gumball";
        }
    };

    struct SoldOutState : public State {
        SoldOutState(GumballMachine *gumballMachine) :
            State(gumballMachine) {}

        virtual string printInfo() {
            return "sold out";
        }
    };
};

int main(int argc, char **argv) {
    GumballMachine *gumballMachine = new GumballMachine(5);

    gumballMachine->printInfo();

    gumballMachine->insertQuarter();
    gumballMachine->turnCrank();
    gumballMachine->printInfo();

    gumballMachine->insertQuarter();
    gumballMachine->turnCrank();

    gumballMachine->insertQuarter();
    gumballMachine->turnCrank();
    gumballMachine->printInfo();

    gumballMachine->insertQuarter();
    gumballMachine->turnCrank();

    gumballMachine->insertQuarter();
    gumballMachine->turnCrank();
    gumballMachine->printInfo();
}