design_pattern_state

最新推荐文章于 2020-09-19 11:05:42 发布
最新推荐文章于 2020-09-19 11:05:42 发布
阅读量298 收藏
点赞数
分类专栏： Design Pattern C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhucai4/article/details/44157333
版权

This post implements state design patter in <Head First Design Pattern>.  The state pattern allows an object to alter its behavior when its internal state changes. The object will appear to change its class. In plain words, when the run-time behavior depends on state and state will change according to behavior at run-time, perhaps we need to consider state pattern.


The State pattern is a solution to the problem of how to make behavior depend on state.

  • Define a "context" class to present a single interface to the outside world.
  • Define a State abstract base class.
  • Represent the different "states" of the state machine as derived classes of the State base class.
  • Define state-specific behavior in the appropriate State derived classes.
  • Maintain a pointer to the current "state" in the "context" class.
  • To change the state of the state machine, change the current "state"pointer.

The State pattern does not specify where the state transitions will be defined. The choices are two: the "context" object, or each individual State derived class. The advantage of the latter option is ease of adding new State derived classes. The disadvantage is each State derived class has knowledge of (coupling to) its siblings, which introduces dependencies between subclasses.

To implement the design, we need to

  1. Identify an existing class, or create a new class, that will serve as the "state machine" from the client's perspective.That class is the "wrapper" class.
  2. Create a State base class that replicates the methods of the state machine interface. Each method takes one additional parameter:an instance of the wrapper class. The State base class specifies any useful "default" behavior.
  3. Create a State derived class for each domain state. These derived classes only override the methods they need to override.
  4. The wrapper class maintains a "current" State object.
  5. All client requests to the wrapper class are simply delegated to the current State object, and the wrapper object'sthis pointer is passed.
  6. The State methods change the "current" state in the wrapper object as appropriate
The example in the book is 

First of all, we define an abstract interface for state

class State {
public:
    virtual void insertQuarter() = 0;
    virtual void ejectQuarter() = 0;
    virtual void turnCrank() = 0;
    virtual void dispense() = 0;
    virtual void toString() = 0;
};
Such abstract class does nothing but defines an uniform interface for states via several pure virtual functions. Then we further implement such interface to define concrete states. We look at HasQuarterState 

class HasQuarterState : public State {
private:
    GumballMachine* gumballMachine;

public:
    HasQuarterState(GumballMachine* gumballMachine) {
		this->gumballMachine = gumballMachine;
	}
	virtual void insertQuarter() {
		std::cout << "You can't insert another quarter" << std::endl;
	}
	virtual void ejectQuarter() {
		std::cout << "Quarter returned" << std::endl;
		gumballMachine->setState(gumballMachine->getNoQuarterState());
	}
    virtual void turnCrank() {
		std::cout << "You turned..." << std::endl;
		gumballMachine->setState(gumballMachine->getSoldState());
	}
    virtual void dispense() {
        std::cout << "No gumball dispensed" << std::endl;
    }
	virtual void toString() {
		std::cout << "waiting for turn of crank" << std::endl;
	}
};
HasQuarterState inherits State. It has a private data member, which points to our gumballMachine. This is because in the state, during conducting certain move, we may change state of gumballMachine. Because we have quarter in the machine, we cannot insertQuarter(), however, we could ejectQuarter(). Moreover, we could use the quarter to buy gumballs, turnCrank. If you do nothing, it will print "waiting for turn of crank". The other states are 

class NoQuarterState : public State {
private:
    GumballMachine* gumballMachine;

public:
    NoQuarterState(GumballMachine* gumballMachine) {
        this->gumballMachine = gumballMachine;
    }
	virtual void insertQuarter() {
		std::cout << "You inserted a quarter" << std::endl;
		gumballMachine->setState(gumballMachine->getHasQuarterState());
	}
	virtual void ejectQuarter() {
		std::cout << "You haven't inserted a quarter" << std::endl;
	}
	virtual void turnCrank() {
		std::cout << "You turned, but there's no quarter" << std::endl;
	}
	virtual void dispense() {
		std::cout << "You need to pay first" << std::endl;
	}
    virtual void toString() {
		std::cout << "waiting for quarter" << std:endl;
	}
};

class SoldOutState : public State {
private:
    GumballMachine* gumballMachine;

public:
    SoldOutState(GumballMachine* gumballMachine) {
        this->gumballMachine = gumballMachine;
    }
	virtual void insertQuarter() {
		std::cout << "You can't insert a quarter, the machine is sold out" << std::endl;
	}
	virtual void ejectQuarter() {
		std::cout << "You can't eject, you haven't inserted a quarter yet" << std::endl;
	}
	virtual void turnCrank() {
		std::cout << "You turned, but there are no gumballs" << std::endl;
	}
	virtual void dispense() {
		std::cout << "No gumball dispensed" << std::endl;
	}
	virtual void toString() {
		std::cout << "sold out" << std::endl;
	}
};

class SoldState : public State {
private:
    GumballMachine* gumballMachine;

public:
    SoldState(GumballMachine* gumballMachine) {
        this->gumballMachine = gumballMachine;
    }
	virtual void insertQuarter() {
		std::cout << "Please wait, we're already giving you a gumball" << std::endl;
	}
	virtual void ejectQuarter() {
		std::cout << "Sorry, you already turned the crank" << std::endl;
	}
    virtual void turnCrank() {
		std::cout << "Turning twice doesn't get you another gumball!" << std::endl;
	}
	virtual void dispense() {
		gumballMachine->releaseBall();
		if (gumballMachine->getCount() > 0) {
			gumballMachine->setState(gumballMachine->getNoQuarterState());
		} else {
			std::cout << "Oops, out of gumballs!" << std::endl;
			gumballMachine->setState(gumballMachine->getSoldOutState());
		}
	}
	virtual void toString() {
		std::cout << "dispensing a gumball" << std::endl;
	}
};
The GumballMachine  class is given by 

#ifndef GUMBALLMACHINE_HPP_INCLUDED
#define GUMBALLMACHINE_HPP_INCLUDED

class GumballMachine {
private:
    State* soldOutState;
	State* noQuarterState;
	State* hasQuarterState;
	State* soldState;

	State* state;	// = soldOutState;
	int count;		// = 0;

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

        this->state = soldOutState;
        this->count = numberGumballs;
        if (numberGumballs > 0) {
            state = noQuarterState;
        }
    }
	virtual void insertQuarter() {
		state->insertQuarter();
	}
	virtual void ejectQuarter() {
		state->ejectQuarter();
	}
	virtual void turnCrank() {
		state->turnCrank();
		state->dispense();
	}
	virtual void setState(State* state) {
		this->state = state;
	}
	virtual void releaseBall() {
		std::cout << "A gumball comes rolling out the slot..." << std::endl;
		if (count != 0) {
			count = count - 1;
		}
	}
	virtual int getCount() { return count; }
	irtual 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; }
	virtual void toString() {
		std::cout << std::endl << "Mighty Gumball, Inc.";
		std::cout << std::endl << "C++-enabled Standing Gumball Model #2004";
		std::cout << std::endl << "Inventory: " << count << " gumball";
		if (count != 1) {
			std::cout << "s";
		}
		std::cout << std::endl;
		std::cout << "Machine is " << state->toString() << std::endl;
	}
};

#endif // GUMBALLMACHINE_HPP_INCLUDED

The main function

int main() {

	GumballMachine* gumballMachine = new GumballMachine(10);

	std::cout << gumballMachine->toString() << std::endl;

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

	std::cout << gumballMachine->toString() << std::endl;

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

	std::cout << gumballMachine->toString() << std::endl;

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

	std::cout << gumballMachine->toString() << std::endl;

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

	std::cout << gumballMachine->toString() << std::endl;

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

	std::cout << gumballMachine->toString() << std::endl;

	return 0;
}



zhucai4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
com.designpattern.state_observer.rar
04-16
用state模式和observer模式一些模式QQ在线状态 com.designpattern.state_observer.rar
Design Pattern_State(状态机模式)
布莱克洛
06-22 743
参考jdon：http://www.jdon.com/designpatterns/designpattern_State.htm 我觉得state应该用的很多，许多动作都是依赖于状态的 说说我理解的几个要点： 1.state主要用在需要多个状态开关切换，且有多种切换方式 2.对象的操作决定于状态 3.将状态和状态相关（甚至是状态切换的操作）都放到state中 4.context负责操
Java Design Pattern: State
不积跬步无以至千里
11-17 1060
In State pattern a class behavior changes based on its state. This type of design pattern comes under behavior pattern. In State pattern, we create objects which represent various states and a contex
Java设计模式之状态模式（State Pattern）
落队的飞行兵
08-27 1105
介绍 状态模式是一种行为型设计模式。当对象在不同状态下有不同行为时使用，在该模式中，我们将对象的不同状态 定义成不同的类，在这些状态类下有它们各自的行为，然后利用环境类使客户端在调用时，不需要显示地去设置状态之间的转换。下面先来看一下它的定义： Allow an object to alter its behavior when its internal state changes...
编译技术笔记（4）
qq_43806430的博客
09-19 299
0.1.2.3.4型文法 用3识别单词，用2分析句子成分 自动机，五元组 子集构造法 先求一条弧便到达的后继结点，再由这些结点得到后续结点 用两重闭包不断生成集合，将生成的新子集，加入到I中，继续寻找新的子集，直到没有新的状态集合生成 对于集合的整理要转换一下思路 一个一个找，逐个查寻 各个子集之间的转换，便是确定的有限自动机 一个状态替代多个状态 状态转移矩阵，子集视为状态 包含终止状态的集合都是终止状态 dfa的化简（最小化） 状态树最少的dfa 删除状态 合并状态 最小化，没有多余的状态以及互相等.
Design Pattern学习笔记之状态机模式（State Patterns）
wqh807020的专栏
12-19 762
Design Pattern学习笔记之状态机模式（State Patterns） 1.    引子--Whois？ 状态机模式用于需要根据内部状态改变行为的场景；状态机模式和策略模式类似但目标不同，策略模式使用通用接口来封装不同算法，而状态机模式使用内部状态控制自身的行为；状态的迁移可在状态类中实现也可以在context中实现，怎么选择要看设计时的考虑（允许哪部分变化）；状态对象可以在多个co
State_Pattern
GZHarryAnonymous的博客
09-24 194
package state_pattern; public abstract class State {     public abstract void Handle(Context context); } package state_pattern; public class ConcreteStateA extends State{     @Override     public v...
design_pattern_observer
海边的八达通
03-04 426
This post implements observer pattern in . Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated aut
Memento_Pattern
GZHarryAnonymous的博客
09-24 250
package memento_pattern; public class Originator {     private String state;     public String getState() {         return state;     }     public void setState(String state) {         this.state =...
Design Pattern - State Pattern
The Secret
07-09 214
概述 State Pattern，即状态模式。让你能在一个对象的内部状态变化时改变其行为，使其看上去就像改变了它所属的类一样。属于行为型设计模式。 又称为状态机模式（state machine pattern），允许对象在它的内在状态发生改变时，修改它的行为。对象看起来好像修改了它的类。 状态模式建议为对象的所有可能状态新建一个类，将所有状态的对应行为提取到这些类中。 状态模式可以视为策略模式的拓展。两者都基于组合机制：它们都通过将部分工作委派给“助手”对象来改变不同场景下的行为。策略使这些对象之间完
getx_pattern:设计模式旨在通过Flutter上的GetX标准化您的项目
03-31
getx_pattern关于使用GetX标准化开发的建议。 客观的便于学习包装。 具有使用GetX开发应用程序的坚固，标准的结构。 以有组织，简单和可扩展的方式促进GetX的使用。 促进信息搜索和知识传播。 使用英文版和新站点多...
design-pattern-java.pdf
04-08
十一个行为型模式 状态模式-State Pattern 处理对象的多种状态及其相互转换——状态模式（一） 处理对象的多种状态及其相互转换——状态模式（二） 处理对象的多种状态及其相互转换——状态模式（三） 处理对象的...
nevstop#LabVIEW-Design-Pattern#状态模式（State Pattern）1
07-25
状态模式定义Allow an object to alter its behavior when its internal state changes. The
CoreJava-DesignPattern
05-31
CoreJava-DesignPattern 创意设计模式 -- Abstract Factory - Done -- Builder - Done -- Factory Method -- Object Pool -- Prototype - Done -- Singleton - Done 结构设计模式 -- Adapter -- Bridge -- ...
design_pattern_singleton
海边的八达通
03-08 518
The Singleton Pattern ensures a class has only one instance, and provides a global point of access to it. What is our motivation to use it? In nearly every application, there is a need to have an
design_pattern_derivative_payoff
海边的八达通
03-21 507
In the option pricing framework, the first component which always changes is option's payoff.  Therefore, we need to  encapsulation the payoff class. First of all, we define an abstract PayOff class,
design_pattern_derivative_randomnumber
海边的八达通
03-22 501
We have implemented payoff, option, statistics class. In our calculation for option price, we have used gsl library to generate random numbers, gsl is a high quality numerical library, however,  to pr
design_pattern_derivative_statistics
海边的八达通
03-22 476
Our monte carlo rounte  lacks any indication of the simulation’s convergence. We could make the routine return standard error, or a convergence table, or simply have it return the value for every sing
vue 中pattern获取值
最新发布
08-23
首先，在Vue的模板中可以使用{{ this.$store.state.pattern }}来获取vuex中的数据。这种方式适用于在模板中直接展示pattern的值。 另外，可以使用this.$refs来获取input元素的值。首先需要给input标签加上ref属性，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值