 | This articleneeds additional citations forverification. Please helpimprove this article byadding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Interpreter pattern" – news ·newspapers ·books ·scholar ·JSTOR(November 2008) (Learn how and when to remove this message) |
Incomputer programming, theinterpreter pattern is adesign pattern that specifies how to evaluate sentences in a language.The basic idea is to have aclass for each symbol (terminal ornonterminal) in aspecialized computer language. Thesyntax tree of a sentence in the language is an instance of thecomposite pattern and is used to evaluate (interpret) the sentence for a client.[1]: 243 See alsoComposite pattern.
The Interpreter[2]design pattern is one of the twenty-three well-knownGoF design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.
Source:[3]
When a problem occurs very often, it could be considered to represent it as a sentence in a simple language(Domain Specific Languages) so that an interpreter can solve the problemby interpreting the sentence.
For example, when many different or complex search expressions must be specified.Implementing (hard-wiring) them directly into a class is inflexiblebecause it commits the class to particular expressions and makes it impossible to specify new expressions or change existing ones independently from (without having to change) the class.
Expression class hierarchy and implementing aninterpret() operation.Expression instances.interpret() on the AST.The expression objects are composed recursively into a composite/tree structure that is calledabstract syntax tree (seeComposite pattern).
The Interpreter pattern doesn't describe howto build an abstract syntax tree. This canbe done either manually by a client or automatically by aparser.
See also the UML class and object diagram below.
In the aboveUMLclass diagram, theClient class refers to the commonAbstractExpression interface for interpreting an expressioninterpret(context).
TheTerminalExpression class has no children and interprets an expression directly.
TheNonTerminalExpression class maintains a container of child expressions(expressions) and forwards interpret requeststo theseexpressions.
The object collaboration diagram shows the run-time interactions: TheClient object sends an interpret request to the abstract syntax tree.The request is forwarded to (performed on) all objects downwards the tree structure.
TheNonTerminalExpression objects (ntExpr1,ntExpr2) forward the request to their child expressions.
TheTerminalExpression objects (tExpr1,tExpr2,…) perform the interpretation directly.
This C++23 implementation is based on the pre C++98 sample code in the book.
importstd;usingString=std::string;template<typenameK,typenameV>usingTreeMap=std::map<K,V>;template<typenameT>usingUniquePtr=std::unique_ptr<T>;classBooleanExpression{public:BooleanExpression()=default;virtual~BooleanExpression()=default;virtualboolevaluate(Context&)=0;virtualUniquePtr<BooleanExpression>replace(String&,BooleanExpression&)=0;virtualUniquePtr<BooleanExpression>copy()const=0;};classVariableExpression;classContext{private:TreeMap<constVariableExpression*,bool>m;public:Context()=default;[[nodiscard]]boollookup(constVariableExpression*key)const{returnm.at(key);}voidassign(VariableExpression*key,boolvalue){m[key]=value;}};classVariableExpression:publicBooleanExpression{private:Stringname;public:VariableExpression(constString&name):name{name}{}virtual~VariableExpression()=default;[[nodiscard]]virtualboolevaluate(Context&context)const{returncontext.lookup(this);}[[nodiscard]]virtualUniquePtr<VariableExpression>replace(constString&name,BooleanExpression&exp){if(this->name==name){returnstd::make_unique<VariableExpression>(exp.copy());}else{returnstd::make_unique<VariableExpression>(name);}}[[nodiscard]]virtualUniquePtr<BooleanExpression>copy()const{returnstd::make_unique<BooleanExpression>(name);}VariableExpression(constVariableExpression&)=delete;VariableExpression&operator=(constVariableExpression&)=delete;};classAndExpression:publicBooleanExpression{private:UniquePtr<BooleanExpression>operand1;UniquePtr<BooleanExpression>operand2;public:AndExpression(UniquePtr<BooleanExpression>op1,UniquePtr<BooleanExpression>op2):operand1{std::move(op1)},operand{std::move(op2)}{}virtual~AndExpression()=default;[[nodiscard]]virtualboolevaluate(Context&context)const{returnoperand1->evaluate(context)&&operand2->evaluate(context);}[[nodiscard]]virtualUniquePtr<BooleanExpression>replace(constString&name,BooleanExpression&exp)const{returnstd::make_unique<AndExpression>(operand1->replace(name,exp),operand2->replace(name,exp));}[[nodiscard]]virtualUniquePtr<BooleanExpression>copy()const{returnstd::make_unique<AndExpression>(operand1->copy(),operand2->copy());}AndExpression(constAndExpression&)=delete;AndExpression&operator=(constAndExpression&)=delete;};intmain(intargc,char*argv[]){UniquePtr<BooleanExpression>expression;Contextcontext;UniquePtr<VariableExpression>x=std::make_unique<VariableExpression>("X");UniquePtr<VariableExpression>y=std::make_unique<VariableExpression>("Y");UniquePtr<BooleanExpression>expression;=std::make_unique<AndExpression>(x,y);context.assign(x.get(),false);context.assign(y.get(),true);boolresult=expression->evaluate(context);std::println("{}",result);context.assign(x.get(),true);context.assign(y.get(),true);result=expression->evaluate(context);std::println("{}",result);return0;}
The program output is:
01
{{cite book}}: CS1 maint: multiple names: authors list (link)