A case study on the application of state mode in C + + design pattern programming Scene _c language

Source: Internet
Author: User

The state pattern allows an object to change its behavior when its internal status changes. The object appears to modify its class.

In object-oriented system development and design process, often encounter a situation is the demand change (requirement changing), often we do a design, realize a system prototype, our customers will have new requirements. And so we have to modify the existing design, the most common is the solution is to have designed and implemented a good class to add new methods to meet the needs of customers, so caught in the nightmare of design changes: constantly patching, the result is that the design is simply impossible to close, the compiler is always the entire system code.

The visitor pattern provides a solution that encapsulates an update (change) into a class (an access operation) and provides a receiving interface for the class to be changed.

Structure Chart:

Instance:
context.h

#ifndef _context_h_
#define _CONTEXT_H_
class state;
/**
*
**/
class context{public
  : Context
  ();
  Context (state* state);
  ~context ();
  void Handle ();
  void Operationforstatea ();
  void Operationforstateb ();
  Protected:
  Private:
  friend class state//indicates that the private field of the context class can be accessed in the State Class
  , and it is important to access the Changestate
  void Changestate (state* state);
  Private:
  state* _state;
#endif//~_context_h_


Context.cpp

#include "Context.h"
#include "State.h"
#include <iostream>
using namespace std;
Context::context () {
}
Context::context (state* state) {
  this->_state = state;
}
Context::~context () {
  delete _state;
}
void Context::handle () {
  _state->handle (this);
}
void Context::changestate (state* state) {
  ///_state->changestate (this,state);
  This->_state = State;
}
void Context::operationforstatea () {
  cout<< "do operation in state A";
}
void Context::operationforstateb () {
  cout<< "do operation in state B";
}


State.h

#ifndef _state_h_
#define _STATE_H_
class context;//predecessor Declaration
Class state{public
  : State
  ();
  Virtual ~state ();
  virtual void Handle (context* con) = 0;
  Protected:
  void Changestate (context* con,state* st);
  Private:
  //bool changestate (context* con,state* st);
Class Concretestatea:public state{public
  :
  Concretestatea ();
  Virtual ~concretestatea ();
  void Handle (context* con);
  Protected:
  private:
};
Class Concretestateb:public state{public
  :
  concretestateb ();
  Virtual ~concretestateb ();
  void Handle (context* con);
  Protected:
  private:
};
#endif//~_state_h_


State.cpp

#include "State.h"
#include "Context.h"
#include <iostream>
using namespace std;
State::state () {
}
state::~state () {
}
void State::changestate (context* con,state* st) {
  con- >changestate (ST);
Concretestatea::concretestatea () {
}
Concretestatea::~concretestatea () {
}
void Concretestatea::handle (context* con) {
  con->operationforstatea ();
  cout<< ":: State change from A to B" <<endl;
  State::changestate (Con,new concretestateb ());
}
Concretestateb::concretestateb () {
}
Concretestateb::~concretestateb () {
}
void Concretestateb::handle (context* con) {
  con->operationforstateb ();
  cout<< ":: State change from B to A" <<endl;
  State::changestate (Con,new Concretestatea ());
}


Main.cpp

#include "Context.h"
#include "State.h"
#include <iostream>
using namespace std;
int main (int argc,char* argv[]) {
  state* st = new Concretestatea ();
  context* con = new context (ST);
  Con->handle ();
  Con->handle ();
  Con->handle ();
  if (Con!= NULL)
    Delete con;
  if (St!= null)
    st = null;
  return 0;
}

You can see that in the test program, three calls to Con->handle (), because of the different con state, you can get the following output:

Do operation in the state A:: The state change from a to B does operation in the State B:: The state change from
B to a do
opera tion in State A:: State change from A to B

Applicability

The behavior of an object depends on its state, and it must change its behavior according to the state at run time.

An operation contains large, multiple-branched conditional statements that depend on the state of the object. This state is usually represented by one or more enumerated constants. Typically, there are multiple operations that contain this same conditional structure. S t a T e mode places each conditional branch into a separate class. This allows you to use the object's state as an object based on the object itself, which can be changed independently of other objects.

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.