領域規則模式

• 在特定領域中,某些變化雖然頻繁,但可以抽象為某種規則。這時候,結合特定領域,將問題抽象為語法規則,從而給出在該領域下的一般性解決方案。

典型模式

• Interpreter

Interpreter

動機( Motivation )

• 在軟體構建過程中,如果某一特定領域的問題比較複雜 ,類似的結構不斷重複出現,如果使用普通的程式設計方式來實現將面臨非常頻繁的變化。
• 在這種情況下,將特定領域的問題表達為某種語法規則下的句子，然後構建一個直譯器來解釋這樣的句子,從而達到解決問題的目的。

模式定義

給定一個語言,定義它的文法的一種表示，並定義一種直譯器，這個直譯器使用該表示來解釋語言中的句子。

結構

要點總結

• Interpreter模式的應用場合是Interpreter模式應用中的難點,只_有滿足“業務規則頻繁變化,且類似的結構不斷重複出現，並且容易抽象為語法規則的問題”才適合使用Interpreter模式。
• 使用Interpreter模式來表示文法規則,從而可以使用面向物件技巧來方便地"擴充套件”文法。
• Interpreter模式比較適合簡單的文法表示,對於複雜的文法表示，Interperter模式會產生比較大的類層次結構, 需要求助於語法分析生成器這樣的標準工具。

cpp

#include<iostream>
#include<map>
#include<string>
#include<stack>

class Expression
{
public:
	virtual int interpreter(std::map<char, int>) = 0;
	virtual ~Expression() {}
};

class VarExpression :public Expression
{
public:
	VarExpression(const char& k) :key(k) {}
	int interpreter(std::map<char, int>var) override
	{
		return var[key];
	}

private:
	char key;
};

class SymbolExpression :public Expression
{
public:
	SymbolExpression(Expression* l, Expression* r) :left(l), right(r) {}
protected:
	Expression* left;
	Expression* right;
};

class AddExpression : public SymbolExpression
{
public:
	AddExpression(Expression* left, Expression* right) :SymbolExpression(left, right) {}
	int interpreter(std::map<char, int> var) override
	{
		return left->interpreter(var) + right->interpreter(var);
	}
};

class SubExpression :public SymbolExpression
{
public:
	SubExpression(Expression* left, Expression* right) :SymbolExpression(left, right) {}
	int interpreter(std::map<char, int> var) override
	{
		return left->interpreter(var) - right->interpreter(var);
	}
};
class MulExpression :public SymbolExpression
{
public:
	MulExpression(Expression* left, Expression* right) :SymbolExpression(left, right) {}
	int interpreter(std::map<char, int> var) override
	{
		return left->interpreter(var) * right->interpreter(var);
	}
};

class DivExpression :public SymbolExpression
{
public:
	DivExpression(Expression* left, Expression* right) :SymbolExpression(left, right) {}
	int interpreter(std::map<char, int> var) override
	{
		return left->interpreter(var) / right->interpreter(var);
	}
};

Expression* analyse(std::string expStr)
{
	std::stack<Expression*> expStack;
	Expression* left = nullptr;
	Expression* right = nullptr;
	for (int i = 0; i < expStr.size(); ++i)
	{
		switch (expStr[i])
		{
		case '+':
			// 加法運算
			left = expStack.top();
			right = new VarExpression(expStr[++i]);
			expStack.push(new AddExpression(left, right));
			break;
		case '-':
			// 減法運算
			left = expStack.top();
			right = new VarExpression(expStr[++i]);
			expStack.push(new SubExpression(left, right));
			break;
		case '*':
			// 乘法運算
			left = expStack.top();
			right = new VarExpression(expStr[++i]);
			expStack.push(new MulExpression(left, right));
			break;
		case '/':
			// 除法運算
			left = expStack.top();
			right = new VarExpression(expStr[++i]);
			expStack.push(new DivExpression(left, right));
			break;
		default:
			// 變量表達式
			expStack.push(new VarExpression(expStr[i]));
		}
	}
	Expression* expression = expStack.top();
	return expression;
}

void release(Expression* expression) {

	//釋放表示式樹的節點記憶體...
}

int main()
{
	std::string expStr = "a+b-c+d-e*f/g";
	std::map<char, int> var;
	var.insert(std::make_pair('a', 5));
	var.insert(std::make_pair('b', 2));
	var.insert(std::make_pair('c', 1));
	var.insert(std::make_pair('d', 6));
	var.insert(std::make_pair('e', 10));
	var.insert(std::make_pair('f', 8));
	var.insert(std::make_pair('g', 4));

	Expression* expression = analyse(expStr);
	int result = expression->interpreter(var);
	std::cout << result << std::endl;

	release(expression);

	return 0;
}