当前位置:编程学习 > C/C++ >>

设计模式C++描述----21.解释器(Iterpreter)模式

一. 解释器模式


定义:给定一个语言,定义它的文法的一种表示,并定一个解释器,这个解释器使用该表示来解释语言中的句子。

结构如下:

 \


代码如下:

[cpp] //包含解释器之外的一些全局信息  
class Context  
{  
public:  
    Context() {} 
 
    ~Context() {} 
}; 
 
 
class AbstractExpression  
{  
public:  
    virtual ~AbstractExpression() {} 
 
    virtual void Interpret(const Context& c) {} 
 
protected:  
    AbstractExpression() {} 
}; 
 
//终结符表达式  
class TerminalExpression:public AbstractExpression  

public:  
    TerminalExpression(const string& statement) 
    { 
        this->_statement = statement; 
    } 
 
    ~TerminalExpression(){} 
 
    void Interpret(const Context& c) 
    { 
        cout<<this->_statement<<" Terminal Expression..."<<endl;  
    } 
 
private:  
    string _statement;  
}; 
 
//非终结符表达式      
class NonterminalExpression:public AbstractExpression  
{  
public:  
    NonterminalExpression(const string& statement) 
    { 
        this->_statement = statement; 
    } 
                  
    ~NonterminalExpression() {} 
 
    void Interpret(const Context& c) 
    { 
        cout<<this->_statement<<" Nonterminal Expression..."<<endl;  
    } 
 
private: 
    string _statement;  
}; 
 
 
//测试代码 www.zzzyk.com   
int main(int argc,char* argv[]) 
{  
    Context* c = new Context(); 
     
    list<AbstractExpression*> ls; 
 
    ls.push_back(new TerminalExpression("A")); 
    ls.push_back(new NonterminalExpression("B")); 
    ls.push_back(new TerminalExpression("C")); 
    ls.push_back(new NonterminalExpression("D")); 
 
    list<AbstractExpression*>::iterator it = ls.begin(); 
    for (it; it != ls.end(); ++it) 
    { 
        (*it)->Interpret(*c); 
    } 
 
    return 0;  

//包含解释器之外的一些全局信息
class Context
{
public:
 Context() {}

 ~Context() {}
};


class AbstractExpression
{
public:
 virtual ~AbstractExpression() {}

 virtual void Interpret(const Context& c) {}

protected:
 AbstractExpression() {}
};

//终结符表达式
class TerminalExpression:public AbstractExpression
{
public:
 TerminalExpression(const string& statement)
 {
  this->_statement = statement;
 }

 ~TerminalExpression(){}

 void Interpret(const Context& c)
 {
  cout<<this->_statement<<" Terminal Expression..."<<endl;
 }

private:
 string _statement;
};

//非终结符表达式 
class NonterminalExpression:public AbstractExpression
{
public:
 NonterminalExpression(const string& statement)
 {
  this->_statement = statement;
 }
    
 ~NonterminalExpression() {}

 void Interpret(const Context& c)
 {
  cout<<this->_statement<<" Nonterminal Expression..."<<endl;
 }

private:
 string _statement;
};


//测试代码
int main(int argc,char* argv[])
{
 Context* c = new Context();
 
 list<AbstractExpression*> ls;

 ls.push_back(new TerminalExpression("A"));
 ls.push_back(new NonterminalExpression("B"));
 ls.push_back(new TerminalExpression("C"));
 ls.push_back(new NonterminalExpression("D"));

 list<AbstractExpression*>::iterator it = ls.begin();
 for (it; it != ls.end(); ++it)
 {
  (*it)->Interpret(*c);
 }

 return 0;
}


二. 说明


解释器模式就是用“迷你语言”来表现程序要解决的问题。

比如:在C语言解释器,当你输入 int 时,解释器就能正确的开辟一个 int 的空间出来。

再比如: linux 下常用的命令参数,如 ls -a,-a 就能被正确的解释成相应的命令。

优点:这种模式很容易改变和扩展文法,因为每个文法有一个文法类,也就是上面的表达式类。

缺点:当文法非常复杂时,要管理和维护很多个文法类。

 


作者 lwbeyond

补充:软件开发 , C++ ,
CopyRight © 2022 站长资源库 编程知识问答 zzzyk.com All Rights Reserved
部分文章来自网络,