设计模式（八）

命令模式

定义：将请求封装成为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。

class Command
{
public:
    virtual void execute() = 0;
};

//将命令封装成对象
class ConcreteCommand : public Command
{
public:
    virtual void execute() override;
};

//将命令封装成对象
class ConcreteCommand2 : public Command
{
    virtual void execute() override;
};

class MacroCommand:public Command
{
    vector<Command*> commands;
public:
    void Add(Command* command)
    {
        //...
    }

    void Remove(Command* command)
    {
        //...
    }

    virtual void execute()
    {
        for(auto command:commands){
            command->execute();
        }
    }
};

void test()
{
    Command* command1 = new ConcreteCommand();
    Command* command2 = new ConcreteCommand2();
    MacroCommand* macroCommand = new MacroCommand();
    macroCommand->Add(command1);
    macroCommand->Add(command2);
    macroCommand->execute();
}

访问器模式

如果要增加新的行为，如果直接在基类中增加会带来变更负担甚至破坏原有设计。

定义：表示一个作用于某对象结构中的各元素的操作。使得可以在不改变各元素的类前提下定义作用域这些元素的新操作。

class Visitor;

class Element
{
public:
    virtual void Func1()=0;

};


class ElementA:public ELement
{
public:
    virtual void Func1()
    {
        //...
    }
};

class ElementB:public Element
{   
public:
    virtual void Func1()
    {
        //...
    }
};
/*
假如要增加Func2，可以为基类增加一个访问器
子类重写Accept
定义一个Visitor子类重写VisitElem方法提供访问能力
*/

class Element
{
public:
    virtual void Accept(Visitor* visitor)=0;
    //...
};

class ElementA:public ELement
{
public:
    virtual void Accapt(Visitor* visitor)
    {
        visitor->VisitElemA(this);
        //...
    }
};

class Visitor1:public Visitor
{
public:
    virtual  void VisitElemA(ElementA* elem)
};

解析器模式

将特定领域的问题抽象成语法问题
定义：给定一个语言，定义它的文法表示，并定义一个解释器。这个解释器使用该标识来解释语言中的句子。

/*
例如一个字符串"a+b-c+d"
我们可以将其解析为一棵树
         +
        / \
        -   d
       / \   
       +   c
     / \
    a   b
*/

class Expression
{
public:
    virtual int Interpreter(map<int,int> var)=0;
    virtual ~Expression(){}
};

class VarExpression:public Expression
{
    char Key;
    puiblic:
    VarExpression(char key)
    {
        this->Key=key;
    }
    virtual int Interpreter(map<int,int> var)
    {
        return var[Key];
    }
};

class SymbolExpression:public Expression
{
    //左右符号
    Expression* Left;
    Expression* Right;
    public:
    SymbolExpression(Expression* left,Expression* right)
    {
        this->Left=left;
        this->Right=right;
    }
};

class AddExpression:public SymbolExpression
{
    public:
    AddExpression(Expression* left,Expression* right)
    {
        SymbolExpression(left,right);
    }
    virtual int Interpreter(map<int,int> var)
    {
        return Left->Interpreter(var)+Right->Interpreter(var);
    }
};

//...

//解析函数
Expression* Analyse(string str)
{
    //...
    //使用switch对str的符号进行解析
}

• 本文作者： KongXinQing
• 本文链接： https://13114987559.github.io/2023/10/17/note/设计模式8/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！