代码改变世界

解释器模式

2015-02-01 11:36  itwolf  阅读(243)  评论(0)  编辑  收藏  举报

一、简介

1、解释器模式给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

2、类成员

（1）AbstractExpression（抽象表达式）：声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。

（2）TerminalExpression（终结符表达式）：实现与文法中的终结符相关联的解释操作。实现抽象表达式中所要求的接口，主要是一个interpreter（）方法。文法中每一个终结符都有一个具体终结表达式与之相对应。

（3）NonterminalExpression（非终结符表达式）：为文法中的非终结符实现解释操作。

（4）Context：包含解释器之外的一些全局信息。

3、UML

4、所属类别：行为型

二、C++程序

  1 // 解释器模式.cpp : 定义控制台应用程序的入口点。
  2 //
  3 
  4 #include "stdafx.h"
  5 #include<iostream>
  6 #include<string>
  7 #include<sstream>
  8 #include<vector>
  9 using namespace std;
 10 
 11 class Contex
 12 {    
 13 public:
 14     string tex;
 15     Contex(){}
 16     ~Contex(){}
 17     void set_contex(string s)
 18     {
 19         tex=s;
 20     }
 21     string get_contex()
 22     {
 23         return tex;
 24     }
 25 };
 26 class Expression
 27 {
 28 public:
 29     Expression(){}
 30     virtual ~Expression(){}
 31     //选择出contex的前两个非空格字符，第一个赋值给key，第二个赋值给value
 32     //然后将contex类中的前两个非零字符删除掉
 33     virtual void interrupt(Contex * contex)
 34     {
 35         if (contex->tex.length()==0)
 36         {
 37             return ;
 38         }
 39         else
 40         {
 41             string str,buf,strr;
 42             vector<string>strs;
 43             str=contex->get_contex();
 44             //取出前两个字符串
 45             string key,value;
 46             key=str[0];
 47             value=str[2];
 48             excute(key,value);
 49             str.erase(0,4);
 50             /*//将str字符串按空格拆分成多个字符串，存放在strs数组中
 51             stringstream ss=stringstream(str);
 52             while(ss>>buf)
 53             {
 54                 strs.push_back(buf);
 55             }
 56             //删除已经取出的字符串，将剩下的字符串重新组合成一个字符写入contex中
 57             vector<string>::iterator it=strs.begin();
 58             strs.erase(it,(it+1));
 59             it=strs.begin();
 60             string s=(*it);
 61             for(;it!=strs.end();it++)
 62             {
 63                 s=s+' '+(*it);
 64             }*/
 65             contex->set_contex(str);
 66             
 67         }
 68 
 69     }
 70     virtual void excute(string key,string value)=0;
 71 };
 72 class Yindiao:public Expression
 73 {
 74 public:
 75     Yindiao(){}
 76     virtual ~Yindiao(){}
 77     virtual void excute(string k,string value)
 78     {
 79         string note;
 80         switch(k[0])
 81         {
 82             case 'C':
 83             note="1";
 84             break;
 85             case 'D':
 86             note="2";
 87             break;
 88             case 'E':
 89             note="3";
 90             break;
 91             case 'F':
 92             note="4";
 93             break;
 94             case 'G':
 95             note="5";
 96             break;
 97             case 'A':
 98             note="6";
 99             break;
100             case 'B':
101             note="7";
102             break;
103         }
104         cout<<note<<endl;
105     }
106 };
107 class Yinfu:public Expression
108 {
109 public:
110     Yinfu(){}
111     virtual ~Yinfu(){}
112     virtual void excute(string k,string value)
113     {
114         string scale;
115         switch(value[0])
116         {
117             case '1':
118             scale="低音";
119             break;
120             case '2':
121             scale="中音";
122             break;
123             case '3':
124             scale="高音";
125             break;
126         }
127         cout<<scale<<endl;
128     }
129 };
130 int _tmain(int argc, _TCHAR* argv[])
131 {
132     Contex *playcontex=new Contex();
133     playcontex->tex="O 2 E 1 A 1 O 1 A 2";
134     Expression* expression=NULL;
135     while(playcontex->tex.length()>0)
136     {
137         //取playtcontex的首字，并根据该首字进行具体的实例化
138         string str=playcontex->tex;
139         switch(str[0])
140         {
141             case 'O':
142                 expression=new Yinfu();
143                 break;
144             case 'C':
145             case 'D':
146             case 'E':
147             case 'F':
148             case 'G':
149             case 'A':
150             case 'B':
151                 expression=new Yindiao();
152                 break;
153         }
154         expression->interrupt(playcontex);
155     }
156     return 0;
157 }