设计模式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.atcpu.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