Une brève introduction aux modèles de conception C et au modèle d'interpréteur

Modèle d'interprète (Interpreter) : Étant donné une langue, définissez une représentation de sa grammaire et définissez un interprète qui utilise la représentation pour interpréter des phrases dans la langue.

Problème résolu par le modèle Interpreter : Si un type particulier de problème se produit assez fréquemment, il peut être intéressant de formuler des instances individuelles de ce problème sous forme de phrase dans un langage simple. Cela permet de construire un interpréteur qui résout le problème en interprétant ces phrases.

L'expression régulière est l'une de ses applications. L'interpréteur définit une grammaire pour les expressions régulières et représente une expression régulière spécifique, ainsi que la manière d'interpréter cette expression régulière.

Quatre rôles :

AbstractExpression : déclare une opération d'interprétation abstraite. Cette interface est partagée par tous les nœuds de l'arbre de syntaxe abstraite.

TerminalExpression : implémente les opérations d'interprétation associées aux symboles terminaux dans la grammaire.

NonterminalExpression : expression non terminale, qui implémente des opérations d'interprétation pour les symboles non terminaux dans la grammaire. Une classe d'expression non terminale spécifique est requise pour chaque règle R1, R2...Rn dans la grammaire.

Contexte : contient des informations globales en dehors de l'interprète.

Implémentation du mode :

[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";
    }
};

Client :

[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;
}

Avantages du mode interprète :

Habituellement, il y a une langue qui doit être interprétée et exécuté et le mode Interpréteur est utilisé lorsque les phrases du langage peuvent être représentées sous la forme d'un arbre de syntaxe abstrait.

Ce qui précède est le contenu d'une brève introduction au modèle de conception C et au mode interpréteur. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !