设计模式——领域规则类及其经典案例

领域规则类

再特定领域中，某些变化虽然频繁，但是可以抽象为某种规则，这个时候只需要结合特定领域，将问题抽象为语法规则，从而给出改领域下的一般性解决方案。
典型模式：
interpreter

interpreter

就这一种动机就不说了，跟上面一样。
比如说我们想实现一个加减运算：

	string expstr = "a+b-c+d";

我们可以提取出一种语法规则如下：

首先我们写一个变量表达式类，先写一个接口

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

再写一个实现：

class varExpression :public expression
{
	char key;
public:
	varExpression(const char& key) :key(key){};
	int interpreter(map<char, int>var) override
	{
		return var[key];
	}
};

再写一个符号表达式

class symbolExpression :public expression
{
protected:
	expression* left;
	expression* right;
public:
	symbolExpression(expression* l, expression* r) :left(l), right(r){};
	virtual ~symbolExpression(){};
};

我们对符号表达式进行实现：

class addexpression :public symbolExpression
{
public:
	addexpression(expression*l, expression*r) :symbolExpression(l, r){};
	int interpreter(map<char, int>var) override
	{
		return left->interpreter(var) + right->interpreter(var);
	}
};
class minusxpression :public symbolExpression
{
public:
	minusxpression(expression*l, expression*r) :symbolExpression(l, r){};
	int interpreter(map<char, int>var) override
	{
		return left->interpreter(var) - right->interpreter(var);
	}
};

最后我们需要解析字符串写一个函数，这一段读者可以参照《大话数据结构》中栈应用;四则混合运算

expression* analyse(string& expstr)
{
	stack<expression*> exStack;
	expression* left = nullptr;
	expression* right = nullptr;
	for (int i = 0; i < expstr.size(); i++)
	{
		switch (expstr[i])
		{
		case'+':
			left = exStack.top();
			right = new varExpression(expstr[++i]);
			exStack.push(new addexpression(left, right));
			break;
		case'-':
			left = exStack.top();
			right = new varExpression(expstr[++i]);
			exStack.push(new minusxpression(left, right));
			break;
		default:
			exStack.push(new varExpression(expstr[i]));
			break;
		}
	}
	expression* expre = exStack.top();
	return expre;
}

这一段代码就是为了构建出一个树，当然这里不是树啦，只是一个栈，里面依次放入add，minus，以及变量表达式abc；
这样我们就可以这样使用：

int main()
{
	string expstr = "a+b-c+d";
	map<char, int> var;
	var.insert(make_pair('a', 5));
	var.insert(make_pair('b', 2));
	var.insert(make_pair('c', 1));
	var.insert(make_pair('d', 6));
	expression* express = analyse(expstr);
	int result = express->interpreter(var);//这一步是解析对应的char
	cout << result << endl;
}

通过这种方式，我们就可以用堆栈 的方式压入整个运算，
有人说这里的top需要改成pop，其实这是错误的，具体原因可以想一想。
建议各位看不懂的可以去看看编译原理里面的四则混合运算，比这玩意儿复杂多了

总结：interpreter适用于义务规则频繁变化但是类似结构不断重复出现的场景，并且容易抽象化的场景。
这种模式比较适合简单文本表述，对于比较复杂的语法，会产生比较大的类层次结构，需要借助语法分析器这样的工具。