解释器模式（C++实现）

（本博客旨在个人总结回顾）

1、详情：

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

说明：

优点： 

①可扩展性比较好，灵活。

②增加了新的解释表达式的方式。

③易于实现简单文法。

缺点： 

①可利用场景比较少。

②对于复杂的文法比较难维护。

③解释器模式会引起类膨胀。 ④解释器模式采用递归调用方法。

使用场景： 

①可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。

②一些重复出现的问题可以用一种简单的语言来进行表达。

③一个简单语法需要解释的场景。

2.1、UML类图：

 

2.2、例子源码

stdafx.h

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <iostream>
using namespace std;

// TODO:  在此处引用程序需要的其他头文件

Expression.h

#pragma once

class Expression
{
public:
    Expression();
    virtual ~Expression();

public:
    virtual bool Interpret(string context) = 0;
};

Expression.cpp

#include "stdafx.h"
#include "Expression.h"

Expression::Expression()
{
}

Expression::~Expression()
{
}

TerminalExpression.h

#pragma once
#include "Expression.h"

class TerminalExpression :
    public Expression
{
public:
    TerminalExpression(string context);
    ~TerminalExpression();

public:
    bool Interpret(string context);

private:
    string m_strData;
};

TerminalExpression.cpp

#include "stdafx.h"
#include "TerminalExpression.h"

TerminalExpression::TerminalExpression(string context)
    : m_strData(context)
{
}

TerminalExpression::~TerminalExpression()
{
}

bool TerminalExpression::Interpret(string context)
{
    if (context.find(m_strData) == string::npos)
    {
        return false;
    }
    return true;
}

OrExpression.h

#pragma once
#include "Handler.h"

class HandlerY :
    public Handler
{
public:
    HandlerY();
    ~HandlerY();

public:
    void HandleRequest(int nRequest);
};

OrExpression.cpp

#include "stdafx.h"
#include "OrExpression.h"

OrExpression::OrExpression(Expression* pExpression1, Expression* pExpression2)
    : m_pExpression1(pExpression1)
    , m_pExpression2(pExpression2)
{
}

OrExpression::~OrExpression()
{
}

bool OrExpression::Interpret(string context)
{
    return m_pExpression1->Interpret(context) || m_pExpression2->Interpret(context);
}

AndExpression.h

#pragma once
#include "Expression.h"

class AndExpression :
    public Expression
{
public:
    AndExpression(Expression* pExpression1, Expression* pExpression2);
    ~AndExpression();

public:
    bool Interpret(string context);

private:
    Expression* m_pExpression1;
    Expression* m_pExpression2;
};

AndExpression.cpp

#include "stdafx.h"
#include "AndExpression.h"

AndExpression::AndExpression(Expression* pExpression1, Expression* pExpression2)
    : m_pExpression1(pExpression1)
    , m_pExpression2(pExpression2)
{
}

AndExpression::~AndExpression()
{
}

bool AndExpression::Interpret(string context)
{
    return m_pExpression1->Interpret(context) && m_pExpression2->Interpret(context);
}

调用代码

InterpreterPatternMemo.cpp

// InterpreterPatternMemo.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "OrExpression.h"
#include "AndExpression.h"
#include "TerminalExpression.h"

int _tmain(int argc, _TCHAR* argv[])
{
    //创建规则：pig 和 dog是 animal（猪狗是动物）
    Expression* pIsAnimal = new OrExpression(new TerminalExpression("pig"), new TerminalExpression("dog"));

    //创建规则：cat is mammalian(猫是哺乳动物)
    Expression* pIsMammalian = new OrExpression(new TerminalExpression("cat"), new TerminalExpression("mammalian"));

    cout << "dog is animal? " << (pIsAnimal->Interpret("dog") == true ? "true" : "false") << endl;
    cout << "cat is mammalian? " << (pIsMammalian->Interpret("cat is mammalian") == true ? "true" : "false") << endl;

    system("pause");
	return 0;
}

2.3、运行结果：