轉載自：
http://patmusing.blog.163.com/blog/static/13583496020101501515558/在軟件構建過程中，如果某一特定領域的問題比較復雜，類似的模式不斷重復出現，如果使用普通的編程方式來實現將面臨非常頻繁的變化。在這種情況下，將特定領域的問題表達為某種語法規則下的句子，然后構建一個解釋器來解釋這樣的句子，從而達到解決問題的目的。
“Given a language, define a represention for its grammar along with an interpreter that uses the representation to interpret sentences in the language.” -GoF
給定一個語言，定義其文法的一種表示，并定義一個解釋器，這個解釋器使用該表示來解釋語言中的句子。
Interpreter設計模式中的幾種角色：
AbstractExpression:
- 聲明一個抽象的Interpret方法，抽象語法樹中所有的節點都必須實現該抽象方法。
TerminalExpression:
- 實現和語法中末端符號相關的Interpret方法。
- 在每個句子的末端符號中均需要一個TerminalExpression實例。
NonterminalExpression:
另外一個實現了AbstractExpression 接口的類，用來處理語法樹中非末端節點的語法。它含有下一個AbstractExpression(s)的引用，調用它每個子節點的Interpret方法。
Context:
Interpreter方法所需要的信息的容器，該信息對Interpreter而言全局可見。充當幾個AbstractExpresssion 實例之間的通訊頻道。
PatternClient:
構建或者接收一個抽象語法書的實例。對于一個特定的句子而言，語法樹往往由若干個TerminalExpressions 和 NonterminalExpression組成。PatterClient在合適的context下，調用Interpret方法。
Interpreter模式的應用場合是interpreter模式應用中的難點，只有滿足“業務規則頻繁變化，且類似的模式不斷重復出現，并且容易抽象為語法規則的問題”才適合使用Interpreter模式。
使用Interpreter模式來表示文法規則，從而可以使用面向對象技巧來方便地“擴展”文法。
Interpreter模式比較適合簡單的文法表示，對于復雜的文法表示，Interpreter模式會產生比較大的類層次結構，這時候就不應該采用Interpreter模式了。
效率不是一個Interpreter關心的關鍵問題。最高效的解釋器通常不是通過直接解釋語法分析樹實現的，而是首先將它們轉換成另一種形式。例如：正則表達式通常被轉換成狀態機。但即使在這種情況下，如果效率不是一個關鍵問題，轉換器仍可用Interpreter模式實現，該模式仍是有用的。
下面是一個將中文數字轉換成阿拉伯數字的例子，其中用到了Interpreter：
// Interpreter.h
#include <iostream>
#include <string>
#include <map>
#include <vector>
using namespace std;
// 下面兩個全局函數，用于處理寬字符中文
// 字符串轉換：string to wstring
wstring s2ws(const std::string& s)
{
setlocale(LC_ALL, "chs");
const char* _Source = s.c_str();
size_t _Dsize = s.size() + 1;
wchar_t *_Dest = new wchar_t[_Dsize];
wmemset(_Dest, 0, _Dsize);
mbstowcs(_Dest,_Source,_Dsize);
std::wstring result = _Dest;
delete []_Dest;
setlocale(LC_ALL, "C");
return result;
}
// 字符串轉換：wstring to string
string ws2s(const std::wstring& ws)
{
std::string curLocale = setlocale(LC_ALL, NULL); // curLocale = "C";
setlocale(LC_ALL, "chs");
const wchar_t* _Source = ws.c_str();
size_t _Dsize = 2 * ws.size() + 1;
char *_Dest = new char[_Dsize];
memset(_Dest,0,_Dsize);
wcstombs(_Dest,_Source,_Dsize);
std::string result = _Dest;
delete []_Dest;
setlocale(LC_ALL, curLocale.c_str());
return result;
}
// Context類，用于保存需要轉換的中文字符串和轉換后的數據
class Context
{
private:
wstring statement; // 需要轉換的中文字符串
int data; // 轉換后的數據
public:
Context(wstring statement) : statement(statement)
{
data = 0;
}
~Context()
{
cout << "in the destructor of Context..." << endl;
}
public:
void set_statement(wstring statement)
{
this->statement = statement;
}
wstring get_statement()
{
return statement;
}
void set_data(int data)
{
this->data = data;
}
int get_data()
{
return data;
}
};
// 抽象Expression
class Expression
{
protected:
map<string, int> dictionary; // 字典，保存與中文對應的阿拉伯數字
public:
Expression()
{
dictionary.insert(pair<string, int>("一", 1));
dictionary.insert(pair<string, int>("二", 2));
dictionary.insert(pair<string, int>("三", 3));
dictionary.insert(pair<string, int>("四", 4));
dictionary.insert(pair<string, int>("五", 5));
dictionary.insert(pair<string, int>("六", 6));
dictionary.insert(pair<string, int>("七", 7));
dictionary.insert(pair<string, int>("八", 8));
dictionary.insert(pair<string, int>("九", 9));
dictionary.insert(pair<string, int>("零", 0));
}
virtual ~Expression()
{
cout << "in the destructor of Expression..." << endl;
}
public:
virtual void Interpret(Context& ctx)
{
wstring statement = ctx.get_statement(); // 從ctx中取出中文字符串
wstring zero_string(s2ws("零")); // 寬字符串“零”
//wstring tempstr = statement.substr(statement.size() - 1);
if(statement.size() == 0) // 從ctx中取出的中文字符串長度等于
{
return; // 處理完成，返回
}
else if(statement.substr(statement.size() - 1) == zero_string) // 如果寬字符串中最后一個寬字符為“零”
{
wstring tempstr = statement;
tempstr = tempstr.substr(0, tempstr.size() - 1); // 將最后的“零”去掉
ctx.set_statement(tempstr);
return;
}
else
{
for(map<string, int>::iterator it = dictionary.begin(); it != dictionary.end(); it++)
{
int value = it->second; // 從字典中取出對應的數字
wstring tempstr2 = statement.substr(statement.size() - get_length());
wstring tempstr3 = s2ws(it->first) + get_postfix();
if(statement.substr(statement.size() - get_length()) == (s2ws(it->first) + get_postfix()))
{
int temp_data = ctx.get_data(); // 取出ctx中保存的數據
temp_data += value * Multiplier();
ctx.set_data(temp_data);
wstring temp_str = ctx.get_statement();
temp_str = temp_str.substr(0, temp_str.size() - get_length());
ctx.set_statement(temp_str);
return;
}
}
}
}
int get_length()
{
return get_postfix().size() + 1;
}
public:
virtual wstring get_postfix() = 0;
virtual int Multiplier() = 0;
};
// GeExpression
class GeExpression : public Expression
{
public:
wstring get_postfix()
{
return s2ws("");
}
int Multiplier()
{
return 1;
}
int get_length()
{
return 1;
}
public:
~GeExpression()
{
cout << "in the destructor of GeExpression..." << endl;
}
};
// ShExpression
class ShExpression : public Expression
{
public:
wstring get_postfix()
{
return s2ws("十");
}
int Multiplier()
{
return 10;
}
public:
~ShExpression()
{
cout << "in the destructor of ShExpression..." << endl;
}
};
// BaExpression
class BaExpression : public Expression
{
public:
wstring get_postfix()
{
return s2ws("百");
}
int Multiplier()
{
return 100;
}
public:
~BaExpression()
{
cout << "in the destructor of BaExpression..." << endl;
}
};
// QiExpression
class QiExpression : public Expression
{
public:
wstring get_postfix()
{
return s2ws("千");
}
int Multiplier()
{
return 1000;
}
public:
~QiExpression()
{
cout << "in the destructor of QiExpression..." << endl;
}
};
// WaExpression
class WaExpression : public Expression
{
public:
wstring get_postfix()
{
return s2ws("萬");
}
int Multiplier()
{
return 10000;
}
void Interpret(Context& ctx)
{
wstring statement = ctx.get_statement(); //一十九零七百三十一萬
wstring zero_string(s2ws("零"));
if(statement.size() == 0)
{
return; // 處理完成，返回
}
else if(statement.substr(statement.size() - 1) == zero_string)
{
wstring tempstr = statement;
tempstr = tempstr.substr(0, tempstr.size() - 1);
ctx.set_statement(tempstr);
return;
}
else
{
vector<Expression*> stx_tree;
stx_tree.push_back(new GeExpression());
stx_tree.push_back(new ShExpression());
stx_tree.push_back(new BaExpression());
stx_tree.push_back(new QiExpression());
if(statement.substr(statement.size() - 1) == get_postfix())
{
int temp_data = ctx.get_data();
ctx.set_data(0);
statement = statement.substr(0, statement.size() - 1);
ctx.set_statement(statement);
for(vector<Expression*>::iterator it = stx_tree.begin(); it != stx_tree.end(); it++)
{
if(ctx.get_statement().size() == 0) break;
(*it)->Interpret(ctx);
}
ctx.set_data(temp_data + ctx.get_data() * Multiplier());
// 刪除語法樹中動態構造的元素，以免內存泄漏
for(vector<Expression*>::iterator it = stx_tree.begin(); it != stx_tree.end(); )
{
Expression *temp = *it;
it = stx_tree.erase(it);
delete temp;
}
return;
}
}
}
public:
~WaExpression()
{
cout << "in the destructor of WaExpression..." << endl;
}
};
// YiExpression
class YiExpression : public Expression
{
public:
wstring get_postfix()
{
return s2ws("億");
}
int Multiplier()
{
return 100000000;
}
void Interpret(Context& ctx)
{
wstring statement = ctx.get_statement();
wstring zero_string(s2ws("零"));
if(statement.size() == 0)
{
return; // 處理完成，返回
}
else if(statement.substr(statement.size() - 1) == zero_string)
{
wstring tempstr = statement;
tempstr = tempstr.substr(0, tempstr.size() - 1);
ctx.set_statement(tempstr);
return;
}
else
{
vector<Expression*> stx_tree;
stx_tree.push_back(new GeExpression());
stx_tree.push_back(new ShExpression());
stx_tree.push_back(new BaExpression());
stx_tree.push_back(new QiExpression());
stx_tree.push_back(new WaExpression());
if(statement.substr(statement.size() - 1) == get_postfix())
{
int temp_data = ctx.get_data();
ctx.set_data(0);
statement = statement.substr(0, statement.size() - 1);
ctx.set_statement(statement);
for(vector<Expression*>::iterator it = stx_tree.begin(); it != stx_tree.end(); it++)
{
if(ctx.get_statement().size() == 0) break;
(*it)->Interpret(ctx);
}
ctx.set_data(temp_data + ctx.get_data() * Multiplier());
// 刪除語法樹中動態構造的元素，以免內存泄漏
for(vector<Expression*>::iterator it = stx_tree.begin(); it != stx_tree.end(); )
{
Expression *temp = *it;
it = stx_tree.erase(it);
delete temp;
}
return;
}
}
}
public:
~YiExpression()
{
cout << "in the destructor of YiExpression..." << endl;
}
};
// Interpreter.cpp
#include "Interpreter.h"
int main(int argc, char **argv)
{
wstring chinese_number = s2ws("一十九億零七百三十一萬六千八百三十九");
Context ctx(chinese_number);
vector<Expression*> stx_tree;
stx_tree.push_back(new GeExpression());
stx_tree.push_back(new ShExpression());
stx_tree.push_back(new BaExpression());
stx_tree.push_back(new QiExpression());
stx_tree.push_back(new WaExpression());
stx_tree.push_back(new YiExpression());
for(vector<Expression*>::iterator it = stx_tree.begin(); it != stx_tree.end(); it++)
{
(*it)->Interpret(ctx);
}
cout << ws2s(chinese_number) << " = " << ctx.get_data() << endl;
// 刪除語法樹中動態構造的元素，以免內存泄漏
for(vector<Expression*>::iterator it = stx_tree.begin(); it != stx_tree.end(); )
{
Expression *temp = *it;
it = stx_tree.erase(it);
delete temp;
}
return 0;
}
上述代碼運行結果：
in the destructor of GeExpression...
in the destructor of Expression...
in the destructor of ShExpression...
in the destructor of Expression...
in the destructor of BaExpression...
in the destructor of Expression...
in the destructor of QiExpression...
in the destructor of Expression...
in the destructor of GeExpression...
in the destructor of Expression...
in the destructor of ShExpression...
in the destructor of Expression...
in the destructor of BaExpression...
in the destructor of Expression...
in the destructor of QiExpression...
in the destructor of Expression...
in the destructor of WaExpression...
in the destructor of Expression...
一十九億零七百三十一萬六千八百三十九 = 1907316839
in the destructor of GeExpression...
in the destructor of Expression...
in the destructor of ShExpression...
in the destructor of Expression...
in the destructor of BaExpression...
in the destructor of Expression...
in the destructor of QiExpression...
in the destructor of Expression...
in the destructor of WaExpression...
in the destructor of Expression...
in the destructor of YiExpression...
in the destructor of Expression...
in the destructor of Context...
上述代碼對應靜態UML類圖：
上圖中GeExpression、ShExpression、BaExpression和QiExpression均為Terminal Expression，WaExpression和YiExpression均為Non-terminal Expression。
上述程序的實際運算步驟：
"十九億零七百三十一萬六千八百三十九" ctx.data = 0
"十九億零七百三十一萬六千八百三十" ctx.data = 9
"十九億零七百三十一萬六千八百" ctx.data = 39
"十九億零七百三十一萬六千" ctx.data = 839
"十九億零七百三十一萬" ctx.data = 6839 (將"萬"去掉)
"十九億零七百三十一" ctx.data = 6839 ("零七百三十一"將遞歸地使用前面已有的Expression)
"十九億" ctx.data = 7316839 (將"億"去掉)
ctx.data = 1907316839