[디자인 모드] 해석 기

해석 기, 응용 장면 이 비교적 고정된 것 같 습 니 다. 특정한 문법 (예 를 들 어 정규 표현 식, 프로 그래 밍 언어) 을 해석 합 니 다.
실제 응용 이 많 지 않 을 수 있 으 니 먼저 가 져 와 서 알 아 보 세 요.이해 가 부족 한 게 틀림 없어.그 오묘 함 을 제대로 깨 닫 지 못 했다.
이 모델 은 상하 문, 표현 식, 고객 으로 구성 되 어 있다.표현 식 은 종결 노드 와 비 종결 노드 로 나 뉜 다.이런 구 조 는 자 연 스 럽 게 재 귀 를 생각 할 것 이다.그 러 니까 성능 이 이상 적 이지 않 을 거 야.물론 디자인 모델 쪽 책 에서 도 이 모델 의 응용 장면 은 성능 에 대해 엄격 한 요구 가 없 는 장면 이 라 고 말 했다.
종결 노드 는 이 노드 의 행 위 를 분석 하 는 것 을 책임 집 니 다. 종결 노드 가 아 닌 보통 바 텀 N 개의 종결 노드 나 비 종결 노드 로 구성 되 는데 그 작업 은 바로 이 N 개의 자손 간 에 이 노드 에서 의 행 위 를 설명 하 는 것 입 니 다.
낡은 계산 기 를 가지 고 데 모 를 간단하게 쓰 는 것 이 좋 겠 다.
 

/***************************************************************************

 * 

 * Copyright (c) 2013 , Inc. All Rights Reserved

 * 

 **************************************************************************/

  

/**

 * @file test_interpreter.cpp

 * @author itegel

 * @date 2013/05/30 14:09:57

 * @brief 

 *  

 **/



#include <stdlib.h>

#include <iostream>

#include <map>

#include <string>

#include <stack>

using namespace std;



//father

class Expression{

    public:

        Expression(){}

        ~Expression(){}

        virtual int Interprete() = 0;

        virtual void AboutMe() = 0;

    protected:

        char _key;

        int _val;

};



//terminal Expression

class VarExpression : public Expression{

    public:

        VarExpression(char key){

            _key = key;

        }

        virtual int Interprete(){

            return _key-'0';

        }

        virtual void AboutMe(){

            cout<<"(var:"<<_key<<")";

        }

};



//Nonterminal Expression

class SymbolExpression : public Expression{

    public:

        SymbolExpression(Expression *left, Expression *right){

            _left = left;

            _right = right;

        }

    virtual int Interprete() = 0;

    virtual void AboutMe() = 0;

   

    protected:

        Expression * _left;

        Expression * _right;

};



//+

class AddExpression : public SymbolExpression{

    public:

        AddExpression(Expression *left, Expression *right):SymbolExpression(left,right){}

        virtual int Interprete(){

            return _left->Interprete() + _right->Interprete();

        }

       

        virtual void AboutMe(){

            _left->AboutMe();

            cout<<"(Sym:+)";

            _right->AboutMe();

        }

};



//-

class SubExpression : public SymbolExpression{

    public:

        SubExpression(Expression *left, Expression *right):SymbolExpression(left,right){}

        virtual int Interprete(){

            return _left->Interprete() - _right->Interprete();

        }

        

        virtual void AboutMe(){

            _left->AboutMe();

            cout<<"(Sym:-)";

            _right->AboutMe();

        }

};



//calculator    0-9      

class Calculator{

    public:

        Calculator(const char * expr){

            _expr_str = expr;

            _expression = NULL;

        }

        ~Calculator(){

            if (_expression){

                delete _expression;

            }

        } 

        void BuildExpression(){

            Expression * left = NULL;

            Expression * right = NULL;

            const char * expr_char = _expr_str;



            cout<<"Building Expression"<<endl;

            for (int i = 0; i < strlen(expr_char); i++){

                switch (expr_char[i]){

                    case '+':

                        cout<<'+';

                        left = tmp_stack.top();

                        right = new VarExpression(expr_char[++i]);

                        cout<<expr_char[i];

                        tmp_stack.push(new AddExpression(left, right));

                        break;

                    case '-':

                        cout<<'-';

                        left = tmp_stack.top();

                        right = new VarExpression(expr_char[++i]);

                        cout<<expr_char[i];

                        tmp_stack.push(new SubExpression(left, right));

                        break;

                    default:

                        cout<<expr_char[i];

                        tmp_stack.push(new VarExpression(expr_char[i]));

                        break;

                }

            }

            _expression = tmp_stack.top();

        }



        Expression * GetExpression(){

            return _expression;

        }



    private:

        const char * _expr_str;

        Expression  * _expression;

        stack<Expression *> tmp_stack;

};



int main(){



    Calculator * cal = new Calculator("1+2-3+4-1-2");

    cal->BuildExpression();

    Expression * expr = cal->GetExpression();

    cout<<endl<<endl<<"Builded Expression:"<<endl;

    expr->AboutMe();

    cout<<endl;

    int val = expr->Interprete();

    cout<<endl<<"Expression Val:"<<val<<endl;



    return 0;

}

실행 결과:
 
Building Expression 1+2-3+4-1-2 Builded Expression: (var:1)(Sym:+)(var:2)(Sym:-)(var:3)(Sym:+)(var:4)(Sym:-)(var:1)(Sym:-)(var:2) Expression Val:1
demo 에서 볼 때 표현 식 의 클래스 구 조 는 비교적 간단 하고 모든 하위 클래스 는 자신의 행동 에 만 관심 을 가 져 야 합 니 다. 후속 확장 은 가장 많 게 는 서로 다른 하위 클래스 만 확장 하여 해당 하 는 작업 을 완성 하면 됩 니 다.
실제로 가장 복잡 한 부분 은 표현 식 트 리 를 만 드 는 과정 일 것 으로 예상 된다.이 예 에서 간단 하기 위해 서 는 가감 법 만 지원 하고 char 를 조작 수로 하기 때문에 한 자리 숫자 만 지원 할 수 있 습 니 다.
해석 기 모드, 장점 은 새로운 조작 을 확장 하 는 것 이 쉽다 는 것 이다.단점 은 모두 성능 이 좋 지 않다 고 말 하지만, 사실 나 도 말 할 수 없다.
개인 적 으로 가장 큰 문 제 는 응용 장면 이 그리 많 지 않 을 수도 있다 는 것 이다.