interpreter 解释器模式

#include <iostream>
#include <string>
using namespace std;

class context
{
public:
    context(){}
    ~context(){}
};

class abstract_expression
{
public:
    virtual ~abstract_expression(){}
    virtual void interpret(const context &c) =0;
protected:
    abstract_expression(){}
};

class terminal_expression : public abstract_expression
{
public:
    terminal_expression(const string &statement): _statement(statement){}
    void interpret(const context &c)
    {
        cout << _statement << " interpret"<<endl;
    }
private:
    string _statement;
};

class noterminal_expression : public abstract_expression
{
public:
    noterminal_expression(abstract_expression *exp, int times): _exp(exp), _times(times){}
    void interpret(const context &c)
    {
        for (int i = 0; i < _times; ++i)
        {
            _exp->interpret(c);
        }
    }
private:
    abstract_expression *_exp;
    int _times;
};

int main()
{
    terminal_expression exp("terminal_expression");
    context c;
    noterminal_expression nexp(&exp, 4);
    nexp.interpret(c);
    return 0;
}