应用场景

1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
2、一些重复出现的问题可以用一种简单的语言来进行表达。
3、一个简单语法需要解释的场景。

• Context.h

#pragma cone

class Context_
{
    public:
        Context_() {}
        ~Context_() {}
    protected:
    private:
};

• Interpret.h

#pragma cone
#include<string>

class Context_;

using namespace std;

class AbstractExpression
{
    public:
        virtual ~AbstractExpression() {}
        virtual void Interpret(const Context_& c) {}
    protected:
        AbstractExpression() {}
    private:
};

class TerminalExpression : public AbstractExpression
{
    public:
        TerminalExpression(const string& statement);
        ~TerminalExpression();
        void Interpret(const Context_& c);
    protected:
    private:
        string _statement;
};

class NonterminalExpression : public AbstractExpression
{
    public:
        NonterminalExpression(AbstractExpression* expression, int times);
        ~NonterminalExpression();
        void Interpret(const Context_& c);
    protected:
    private:
        AbstractExpression* _expression;
        int _times;
};

• Interpret.cpp

#include"Interpret.h"
#include"Context.h"
#include<iostream>

using namespace std;

TerminalExpression::TerminalExpression(const string& statement)
{
    this->_statement = statement;
}

TerminalExpression::~TerminalExpression()
{

}

void TerminalExpression::Interpret(const Context_& c)
{
    cout << this->_statement << "TerminalExpression" << endl;
}


NonterminalExpression::NonterminalExpression(AbstractExpression* expression, int times)
{
    this->_expression = expression;
    this->_times = times;
}

NonterminalExpression::~NonterminalExpression()
{

}

void NonterminalExpression::Interpret(const Context_& c)
{
    for(int i = 0; i < _times; i++)
    {
        this->_expression->Interpret(c);
    }
}

• main.cpp

#include<iostream>
#include"Context.h"
#include"Interpret.h"

using namespace std;

int main(int argc, char* argv[])
{
    Context_* c = new Context_();
    AbstractExpression* te = new TerminalExpression("hello");
    AbstractExpression* nte = new NonterminalExpression(te, 2);
    nte->Interpret(*c);
    return 0;
}