積木

No sub title

C++博客 :: 首頁 :: 聯系 :: 聚合

:: 管理

140 Posts :: 1 Stories :: 11 Comments :: 0 Trackbacks

常用鏈接

留言簿(1)

我參與的團隊

隨筆分類

隨筆檔案

搜索

閱讀排行榜

評論排行榜

【轉載】 C++實現Behavioral - Interpreter模式

轉載自：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...