Eine kurze Einführung in C++-Entwurfsmuster und Interpretermuster

Interpretermuster (Interpreter): Definieren Sie für eine gegebene Sprache eine Darstellung ihrer Grammatik und einen Interpreter, der die Darstellung zum Interpretieren von Sätzen in der Sprache verwendet.

Problem gelöst durch das Interpreter-Muster: Wenn eine bestimmte Art von Problem häufig genug auftritt, kann es sich lohnen, einzelne Instanzen dieses Problems als Satz in einer einfachen Sprache zu formulieren. Dadurch ist es möglich, einen Dolmetscher zu bauen, der das Problem durch Interpretation dieser Sätze löst.

Regulärer Ausdruck ist eine seiner Anwendungen. Der Interpreter definiert eine Grammatik für reguläre Ausdrücke und stellt einen bestimmten regulären Ausdruck sowie die Interpretation dieses regulären Ausdrucks dar.

Vier Rollen:

AbstractExpression: deklariert eine abstrakte Interpretationsoperation. Diese Schnittstelle wird von allen Knoten im abstrakten Syntaxbaum gemeinsam genutzt.

TerminalExpression: implementiert Interpretationsoperationen, die mit Terminalsymbolen in der Grammatik verbunden sind.

NonterminalExpression: Nichtterminaler Ausdruck, der Interpretationsoperationen für nichtterminale Symbole in der Grammatik implementiert. Jede Regel R1, R2...Rn in der Grammatik erfordert eine bestimmte nichtterminale Ausdrucksklasse.

Kontext: Enthält einige globale Informationen außerhalb des Interpreters.

Modusimplementierung:

[code]//Context
class Context{
private:
    std::string input;
public:
    std::string Input(std::string in){
        input = in;
        return input;
    }
};

//抽象表达式
class AbstractExpression{
public:
    virtual void Interpret(Context *context) = 0;
};

//终结符表达式
class TerminalExpression: public AbstractExpression{
public:
    void Interpret(Context *context)override{
        std::cout << "TerminalExpression\n";
    }
};

//非终结符表达式
class NonterminalExpression: public AbstractExpression{
public:
    void Interpret(Context *context)override{
        std::cout << "NonterminalExpression\n";
    }
};

Kunde:

[code]//Client
int main(){
    Context *context = new Context;
    std::list<AbstractExpression*> list;
    list.push_back(new TerminalExpression);
    list.push_back(new NonterminalExpression);
    list.push_back(new TerminalExpression);
    list.push_back(new TerminalExpression);

    for(auto i : list)
        i->Interpret(context);
    // Output:
    // TerminalExpression
    // NonterminalExpression
    // TerminalExpression
    // TerminalExpression

    return 0;
}

Vorteile des Dolmetschermodus:

Normalerweise gibt es eine Sprache, die interpretiert werden muss und ausgeführt, und der Interpretermodus wird verwendet, wenn Sätze in der Sprache als abstrakter Syntaxbaum dargestellt werden können.

Das Obige ist der Inhalt einer kurzen Einführung in den Interpretermodus von C++-Entwurfsmustern. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (m.sbmmt.com).