企业官网建设流程全解析

蓬莱建设管理局网站,大庆建设局网站迁址,无锡做网站费用,网店怎么开怎么运营设计模式概述 1. 创建型模式 (Creational Patterns) 关注点#xff1a;对象的创建过程 核心思想#xff1a;将对象的创建与使用分离#xff0c;避免紧耦合 解决的问题#xff1a;如何创建对象#xff0c;使系统更灵活、可扩展 特点#xff1a;隔离对象的创建和使用#…设计模式概述1. 创建型模式 (Creational Patterns)关注点对象的创建过程核心思想将对象的创建与使用分离避免紧耦合解决的问题如何创建对象使系统更灵活、可扩展特点隔离对象的创建和使用提供灵活的对象创建机制常见模式单例、工厂方法、抽象工厂、建造者、原型2. 结构型模式 (Structural Patterns)关注点类和对象的组合核心思想通过组合形成更大的结构使设计更灵活解决的问题如何组合类和对象形成更复杂的结构特点通过组合形成更复杂的结构提供更灵活的系统架构常见模式适配器、桥接、组合、装饰器、外观、享元、代理3. 行为型模式 (Behavioral Patterns)关注点对象之间的通信和职责分配核心思想优化对象之间的交互明确对象的职责解决的问题如何分配对象职责和通信使系统更灵活特点优化对象之间的交互明确对象的职责提高系统的灵活性和可扩展性常见模式策略、观察者、命令、状态、责任链、迭代器、模板方法等本文将详细介绍11种行为型模式包括策略、模板方法、观察者、迭代器、命令、状态、责任链、备忘录、解释器、访问者和中介者模式。行为型设计模式对比表模式重要程度核心用途关键特点C最佳实践策略模式5封装可互换的算法使算法独立于使用它的客户端算法解耦动态切换符合开闭原则使用std::shared_ptr定义策略接口上下文类持有一个策略指针通过setStrategy()动态切换策略观察者模式5建立一对多依赖关系状态变化时自动通知所有观察者解耦主题与观察者支持广播通信使用std::vectorstd::shared_ptrObserver管理观察者列表使用std::weak_ptr避免循环引用模板方法模式4定义算法骨架将某些步骤延迟到子类实现提高代码复用性子类可重定义特定步骤定义final模板方法抽象基类定义骨架具体子类实现可变步骤命令模式4将请求封装为对象支持参数化、队列化、撤销/重做分离调用者与执行者支持日志记录和异步执行定义Command基类包含execute()和undo()方法具体命令类实现具体操作迭代器模式4提供统一接口遍历集合元素隐藏底层实现分离遍历逻辑与集合结构支持多种遍历方式实现next()、hasNext()方法使用智能指针管理元素避免越界状态模式3允许对象在其内部状态改变时改变其行为状态决定行为状态转换由状态对象自身控制状态对象自身控制状态转换上下文类只持有一个状态指针责任链模式3将请求沿处理链传递直到被某个对象处理解耦请求发送者与接收者动态调整处理顺序定义统一处理接口每个处理器持有下一个处理器引用中介者模式3用中介对象封装一组对象交互减少直接耦合将网状交互转为星形结构简化多方通信定义中介接口具体中介类实现交互逻辑避免对象间直接引用访问者模式2在不改变元素前提下为元素提供多种访问方式操作与元素解耦支持添加新操作元素类提供accept(Visitor*)方法访问者类实现visit()方法备忘录模式2在不破坏封装性前提下获取并保存对象内部状态状态保存与恢复封装性良好使用备忘录类保存状态发起人提供save()和restore()方法解释器模式1定义语言语法规则并解释执行适用于简单语法复杂语法需结合编译器技术定义抽象语法树节点具体解释器实现解析逻辑详细解析1. 策略模式 (Strategy) - 重要程度: 5关键点封装算法族可互相替换优点算法独立于使用它的客户符合开闭原则新增算法只需添加新策略运行时可切换算法缺点增加策略类数量客户端需要知道所有策略策略类可能相似C最佳实现 (详细注释)// 策略接口定义算法行为classStrategy{public:virtual~Strategy()default;virtualvoidalgorithm()0;// 算法执行方法};// 具体策略A实现特定算法classConcreteStrategyA:publicStrategy{public:voidalgorithm()override{std::coutConcreteStrategyA: executing algorithm\n;}};// 具体策略B实现特定算法classConcreteStrategyB:publicStrategy{public:voidalgorithm()override{std::coutConcreteStrategyB: executing algorithm\n;}};// 上下文使用策略classContext{public:// 构造函数初始化默认策略Context(std::shared_ptrStrategystrategy):strategy(strategy){}// 设置新策略切换算法voidsetStrategy(std::shared_ptrStrategystrategy){this-strategystrategy;}// 执行算法委托策略执行voidexecuteStrategy(){strategy-algorithm();// 调用当前策略的算法}private:std::shared_ptrStrategystrategy;// 当前策略};调用方式intmain(){autostrategyAstd::make_sharedConcreteStrategyA();autostrategyBstd::make_sharedConcreteStrategyB();Contextcontext(strategyA);context.executeStrategy();// 输出: ConcreteStrategyA: executing algorithmcontext.setStrategy(strategyB);context.executeStrategy();// 输出: ConcreteStrategyB: executing algorithmreturn0;}类图 (Mermaid)«interface»Strategyalgorithm()ConcreteStrategyAalgorithm()ConcreteStrategyBalgorithm()Context-strategy: StrategyContext(strategy: Strategy)setStrategy(strategy: Strategy)executeStrategy()2. 观察者模式 (Observer) - 重要程度: 5关键点一对多依赖关系状态变化自动通知优点完全解耦发布者和订阅者支持动态添加/移除观察者符合开闭原则新增观察者无需修改发布者缺点内存泄漏风险未移除的观察者会持续持有引用通知顺序不确定可能造成逻辑混乱状态频繁变化时性能开销大C最佳实现 (详细注释)// 观察者接口定义更新方法// 所有观察者必须实现update()方法classObserver{public:virtual~Observer()default;virtualvoidupdate()0;// 通知方法};// 被观察者接口定义注册/移除/通知方法classSubject{public:virtual~Subject()default;// 注册观察者virtualvoidattach(std::shared_ptrObserverobserver)0;// 移除观察者virtualvoiddetach(std::shared_ptrObserverobserver)0;// 通知所有观察者virtualvoidnotify()0;};// 具体被观察者维护观察者列表classConcreteSubject:publicSubject{public:// 注册观察者添加到观察者列表voidattach(std::shared_ptrObserverobserver)override{observers.push_back(observer);}// 移除观察者从列表中移除指定观察者voiddetach(std::shared_ptrObserverobserver)override{// 使用erase-remove惯用法高效移除observers.erase(std::remove(observers.begin(),observers.end(),observer),observers.end());}// 通知所有观察者遍历列表调用updatevoidnotify()override{for(autoobserver:observers){observer-update();// 触发观察者更新}}private:std::vectorstd::shared_ptrObserverobservers;// 观察者列表};// 具体观察者实现更新逻辑classConcreteObserver:publicObserver{public:ConcreteObserver(conststd::stringname):name(name){}// 实现更新方法打印通知信息voidupdate()override{std::coutObserver name received notification\n;}private:std::string name;// 观察者标识};调用方式intmain(){autosubjectstd::make_sharedConcreteSubject();autoobserverAstd::make_sharedConcreteObserver(A);autoobserverBstd::make_sharedConcreteObserver(B);subject-attach(observerA);subject-attach(observerB);subject-notify();// 输出: Observer A received notification, Observer B received notificationsubject-detach(observerA);subject-notify();// 输出: Observer B received notificationreturn0;}类图 (Mermaid)«interface»Observerupdate()«interface»Subjectattach(observer: Observer)detach(observer: Observer)notify()ConcreteSubjectattach(observer: Observer)detach(observer: Observer)notify()ConcreteObserverupdate()3. 模板方法模式 (Template Method) - 重要程度: 4关键点定义算法骨架将步骤延迟到子类实现优点避免重复代码核心算法只写一次符合开闭原则扩展算法只需新增子类提高代码可维护性缺点模板方法可能过于僵化难以改变算法流程子类数量可能增多无法在运行时动态改变算法C最佳实现 (详细注释)// 抽象基类定义模板方法和抽象步骤// 模板方法templateMethod是最终被调用的主方法不可被重写// 通过protected定义的纯虚函数将具体实现延迟到子类classAbstractClass{public:// 模板方法定义算法骨架核心流程voidtemplateMethod(){// 步骤1调用子类实现的抽象方法primitiveOperation1();// 步骤2调用子类实现的抽象方法primitiveOperation2();// 步骤3调用子类实现的抽象方法primitiveOperation3();}protected:// 抽象步骤1由子类实现具体逻辑virtualvoidprimitiveOperation1()0;// 抽象步骤2由子类实现具体逻辑virtualvoidprimitiveOperation2()0;// 抽象步骤3由子类实现具体逻辑virtualvoidprimitiveOperation3()0;};// 具体实现类A实现算法的特定步骤classConcreteClassA:publicAbstractClass{protected:// 实现步骤1具体业务逻辑voidprimitiveOperation1()override{std::coutConcreteClassA: Step 1 implementation\n;}// 实现步骤2具体业务逻辑voidprimitiveOperation2()override{std::coutConcreteClassA: Step 2 implementation\n;}// 实现步骤3具体业务逻辑voidprimitiveOperation3()override{std::coutConcreteClassA: Step 3 implementation\n;}};// 具体实现类B实现算法的特定步骤classConcreteClassB:publicAbstractClass{protected:// 实现步骤1不同业务逻辑voidprimitiveOperation1()override{std::coutConcreteClassB: Step 1 implementation\n;}// 实现步骤2不同业务逻辑voidprimitiveOperation2()override{std::coutConcreteClassB: Step 2 implementation\n;}// 实现步骤3不同业务逻辑voidprimitiveOperation3()override{std::coutConcreteClassB: Step 3 implementation\n;}};调用方式intmain(){ConcreteClassA concreteA;concreteA.templateMethod();// 输出: Step 1, Step 2, Step 3 (A版)ConcreteClassB concreteB;concreteB.templateMethod();// 输出: Step 1, Step 2, Step 3 (B版)return0;}类图 (Mermaid)«abstract»AbstractClasstemplateMethod()primitiveOperation1()primitiveOperation2()primitiveOperation3()ConcreteClassAprimitiveOperation1()primitiveOperation2()primitiveOperation3()ConcreteClassBprimitiveOperation1()primitiveOperation2()primitiveOperation3()4. 命令模式 (Command) - 重要程度: 4关键点请求封装为对象支持参数化优点解耦请求发送者和接收者支持请求排队/日志/撤销符合开闭原则缺点增加命令类数量代码复杂度上升内存消耗可能增加C最佳实现 (详细注释)// 命令接口定义执行方法classCommand{public:virtual~Command()default;virtualvoidexecute()0;// 执行命令};// 接收者执行具体操作classReceiver{public:voidaction(){std::coutReceiver: executing action\n;}};// 具体命令封装接收者和操作classConcreteCommand:publicCommand{public:// 构造函数绑定接收者ConcreteCommand(std::shared_ptrReceiverreceiver):receiver(receiver){}voidexecute()override{receiver-action();// 调用接收者执行}private:std::shared_ptrReceiverreceiver;// 接收者对象};// 调用者触发命令执行classInvoker{public:// 设置命令voidsetCommand(std::shared_ptrCommandcommand){this-commandcommand;}// 执行命令voidexecuteCommand(){command-execute();// 执行绑定的命令}private:std::shared_ptrCommandcommand;// 当前命令};调用方式intmain(){autoreceiverstd::make_sharedReceiver();autocommandstd::make_sharedConcreteCommand(receiver);autoinvokerstd::make_sharedInvoker();invoker-setCommand(command);invoker-executeCommand();// 输出: Receiver: executing actionreturn0;}类图 (Mermaid)«interface»Commandexecute()Receiveraction()ConcreteCommandexecute()Invoker-command: CommandsetCommand(command: Command)executeCommand()5. 迭代器模式 (Iterator) - 重要程度: 4关键点提供顺序访问聚合对象元素的方法优点解耦遍历逻辑和聚合对象使遍历方式更灵活符合开闭原则缺点增加类数量可能增加内存消耗迭代器可能复杂C最佳实现 (详细注释)// 迭代器接口定义遍历方法classIterator{public:virtual~Iterator()default;// 检查是否还有元素virtualboolhasNext()0;// 获取下一个元素virtualstd::shared_ptrObjectnext()0;};// 聚合接口创建迭代器classAggregate{public:virtual~Aggregate()default;// 创建迭代器virtualstd::shared_ptrIteratorcreateIterator()0;};// 具体对象classObject{public:Object(intvalue):value(value){}intgetValue()const{returnvalue;}private:intvalue;// 对象值};// 具体聚合实现创建迭代器classConcreteAggregate:publicAggregate{public:// 添加对象voidadd(std::shared_ptrObjectobj){objects.push_back(obj);}// 创建迭代器std::shared_ptrIteratorcreateIterator()override{returnstd::make_sharedConcreteIterator(objects);}private:std::vectorstd::shared_ptrObjectobjects;// 对象列表};// 具体迭代器实现遍历逻辑classConcreteIterator:publicIterator{public:// 构造函数初始化迭代器ConcreteIterator(conststd::vectorstd::shared_ptrObjectobjects):objects(objects),index(0){}// 检查是否有下一个元素boolhasNext()override{returnindexobjects.size();}// 注意返回当前元素移动索引到下一个元素std::shared_ptrObjectnext()override{if(hasNext()){returnobjects[index];}returnnullptr;}private:std::vectorstd::shared_ptrObjectobjects;// 聚合对象intindex;// 当前索引};调用方式intmain(){autoaggregatestd::make_sharedConcreteAggregate();aggregate-add(std::make_sharedObject(1));aggregate-add(std::make_sharedObject(2));autoiteratoraggregate-createIterator();while(iterator-hasNext()){std::coutiterator-next()-getValue() ;// 输出: 1 2}return0;}类图 (Mermaid)«interface»IteratorhasNext()next()«interface»AggregatecreateIterator()Object-value: intObject(value: int)getValue()ConcreteAggregateadd(obj: Object)createIterator()ConcreteIteratorhasNext()next()6. 状态模式 (State) - 重要程度: 3关键点对象状态变化时改变行为优点将状态转换逻辑封装在状态类中避免过多if/else条件判断状态转换清晰可维护缺点增加状态类数量状态类间可能有相互依赖状态转换逻辑可能分散C最佳实现 (详细注释)#includeiostream#includememory// 状态接口classState{public:virtualvoidhandle(Context*context)0;virtual~State()default;};// 具体状态AclassConcreteStateA:publicState{public:voidhandle(Context*context)override{std::coutConcreteStateA: handling request, switching to State Bstd::endl;context-setState(std::make_sharedConcreteStateB());// 状态转换由状态对象自身触发}};// 具体状态BclassConcreteStateB:publicState{public:voidhandle(Context*context)override{std::coutConcreteStateB: handling request, switching to State Astd::endl;context-setState(std::make_sharedConcreteStateA());// 状态转换由状态对象自身触发}};// 上下文类classContext{private:std::shared_ptrStatestate;public:Context(std::shared_ptrStateinitialState):state(initialState){}voidsetState(std::shared_ptrStatenewState){statenewState;}voidrequest(){state-handle(this);// 由当前状态决定如何处理}};调用方式intmain(){// 创建上下文初始状态为ConcreteStateAautocontextstd::make_sharedContext(std::make_sharedConcreteStateA());// 第一次请求从StateA开始context-request();// 输出: ConcreteStateA: handling request, switching to State B// 第二次请求自动切换到StateB并处理context-request();// 输出: ConcreteStateB: handling request, switching to State A// 第三次请求自动切换回StateAcontext-request();// 输出: ConcreteStateA: handling request, switching to State Breturn0;}类图 (Mermaid)«interface»Statehandle()ConcreteStateAhandle()ConcreteStateBhandle()Context-state: StateContext(state: State)setState(state: State)request()7. 职责链模式 (Chain of Responsibility) - 重要程度: 3关键点请求传递处理避免耦合优点解耦请求发送者和接收者符合开闭原则新增处理者无需修改发送者请求处理流程可动态配置缺点请求可能未被处理处理顺序不明确链过长时性能下降C最佳实现 (详细注释)// 处理者接口定义处理请求方法classHandler{public:virtual~Handler()default;// 设置下一个处理者链式结构voidsetSuccessor(std::shared_ptrHandlersuccessor){this-successorsuccessor;}// 处理请求抽象方法virtualvoidhandleRequest(intrequest)0;protected:std::shared_ptrHandlersuccessor;// 下一个处理者};// 具体处理者A处理0-9的请求classConcreteHandlerA:publicHandler{public:voidhandleRequest(intrequest)override{// 本处理者处理范围if(request0request10){std::coutConcreteHandlerA: handled request request\n;}// 未处理则传递给下一个elseif(successor){successor-handleRequest(request);}}};// 具体处理者B处理10-19的请求classConcreteHandlerB:publicHandler{public:voidhandleRequest(intrequest)override{// 本处理者处理范围if(request10request20){std::coutConcreteHandlerB: handled request request\n;}// 未处理则传递给下一个elseif(successor){successor-handleRequest(request);}}};调用方式intmain(){autohandlerAstd::make_sharedConcreteHandlerA();autohandlerBstd::make_sharedConcreteHandlerB();handlerA-setSuccessor(handlerB);// 链接: A → BhandlerA-handleRequest(5);// 输出: ConcreteHandlerA: handled request 5handlerA-handleRequest(15);// 输出: ConcreteHandlerB: handled request 15return0;}类图 (Mermaid)«abstract»Handler-successor: HandlersetSuccessor(successor: Handler)handleRequest(request: int)ConcreteHandlerAhandleRequest(request: int)ConcreteHandlerBhandleRequest(request: int)8. 中介者模式 (Mediator) - 重要程度: 3关键点用中介对象封装对象交互优点降低对象间耦合度使交互逻辑集中管理符合开闭原则缺点中介者可能变得复杂增加类数量可能成为性能瓶颈C最佳实现 (详细注释)// 中介者接口定义通信方法classMediator{public:virtual~Mediator()default;// 通知方法接收来自同事的事件virtualvoidnotify(std::shared_ptrclassColleaguecolleague,conststd::stringevent)0;};// 同事类拥有中介者引用classColleague{public:// 构造函数绑定中介者Colleague(std::shared_ptrMediatormediator):mediator(mediator){}// 设置中介者voidsetMediator(std::shared_ptrMediatormediator){this-mediatormediator;}// 通知事件抽象方法virtualvoidnotify(conststd::stringevent)0;protected:std::shared_ptrMediatormediator;// 中介者引用};// 具体同事A实现通知逻辑classConcreteColleagueA:publicColleague{public:ConcreteColleagueA(std::shared_ptrMediatormediator):Colleague(mediator){}voidnotify(conststd::stringevent)override{std::coutConcreteColleagueA: event\n;}// 发送事件通过中介者转发voidsend(conststd::stringevent){mediator-notify(std::dynamic_pointer_castColleague(shared_from_this()),event);}};// 具体同事B实现通知逻辑classConcreteColleagueB:publicColleague{public:ConcreteColleagueB(std::shared_ptrMediatormediator):Colleague(mediator){}voidnotify(conststd::stringevent)override{std::coutConcreteColleagueB: event\n;}// 发送事件通过中介者转发voidsend(conststd::stringevent){mediator-notify(std::dynamic_pointer_castColleague(shared_from_this()),event);}};// 具体中介者实现通信逻辑classConcreteMediator:publicMediator{public:// 设置同事AvoidsetColleagueA(std::shared_ptrConcreteColleagueAcolleagueA){this-colleagueAcolleagueA;}// 设置同事BvoidsetColleagueB(std::shared_ptrConcreteColleagueBcolleagueB){this-colleagueBcolleagueB;}// 通知处理根据发送者转发事件voidnotify(std::shared_ptrColleaguecolleague,conststd::stringevent)override{if(colleaguecolleagueA){colleagueB-notify(event);// 转发给B}else{colleagueA-notify(event);// 转发给A}}private:std::shared_ptrConcreteColleagueAcolleagueA;std::shared_ptrConcreteColleagueBcolleagueB;};调用方式 (详细说明)intmain(){// 创建中介者automediatorstd::make_sharedConcreteMediator();// 创建同事A和B并设置同一个中介者autocolleagueAstd::make_sharedConcreteColleagueA(mediator);autocolleagueBstd::make_sharedConcreteColleagueB(mediator);mediator-setColleagueA(colleagueA);mediator-setColleagueB(colleagueB);// 发送事件A发送给BB发送给AcolleagueA-send(Hello from A);// 输出: ConcreteColleagueB: Hello from AcolleagueB-send(Hi from B);// 输出: ConcreteColleagueA: Hi from Breturn0;}类图 (Mermaid)«interface»Mediatornotify(colleague: Colleague, event: string)«abstract»Colleague-mediator: Mediatornotify(event: string)ConcreteColleagueAnotify(event: string)send(event: string)ConcreteColleagueBnotify(event: string)send(event: string)ConcreteMediatornotify(colleague: Colleague, event: string)setColleagueA(colleagueA: ConcreteColleagueA)setColleagueB(colleagueB: ConcreteColleagueB)9. 访问者模式 (Visitor) - 重要程度: 2关键点在不改变元素类的前提下定义新操作优点数据结构与操作分离新操作易于添加符合开闭原则缺点增加类数量对象结构复杂度增加访问者与元素耦合C最佳实现 (详细注释)// 访问者接口定义访问方法classVisitor{public:virtual~Visitor()default;// 访问具体元素AvirtualvoidvisitConcreteElementA(std::shared_ptrclassConcreteElementAelement)0;// 访问具体元素BvirtualvoidvisitConcreteElementB(std::shared_ptrclassConcreteElementBelement)0;};// 元素接口定义接受访问者classElement{public:virtual~Element()default;// 接受访问者virtualvoidaccept(std::shared_ptrVisitorvisitor)0;};// 具体元素A实现接受方法classConcreteElementA:publicElement{public:// 接受访问者调用访问者对应方法voidaccept(std::shared_ptrVisitorvisitor)override{visitor-visitConcreteElementA(std::dynamic_pointer_castConcreteElementA(shared_from_this()));}// 元素特定操作voidoperationA(){std::coutConcreteElementA: operationA\n;}};// 具体元素B实现接受方法classConcreteElementB:publicElement{public:// 接受访问者调用访问者对应方法voidaccept(std::shared_ptrVisitorvisitor)override{visitor-visitConcreteElementB(std::dynamic_pointer_castConcreteElementB(shared_from_this()));}// 元素特定操作voidoperationB(){std::coutConcreteElementB: operationB\n;}};// 具体访问者实现访问方法classConcreteVisitor:publicVisitor{public:// 访问元素AvoidvisitConcreteElementA(std::shared_ptrConcreteElementAelement)override{element-operationA();// 调用元素A的操作}// 访问元素BvoidvisitConcreteElementB(std::shared_ptrConcreteElementBelement)override{element-operationB();// 调用元素B的操作}};调用方式 (详细说明)intmain(){autoelementAstd::make_sharedConcreteElementA();autoelementBstd::make_sharedConcreteElementB();autovisitorstd::make_sharedConcreteVisitor();elementA-accept(visitor);// 输出: ConcreteElementA: operationAelementB-accept(visitor);// 输出: ConcreteElementB: operationBreturn0;}深刻思考下访问者模式的好处当元素ConcreteElement数量很多时新增一个接口所有元素都要新增如果用访问者模式只需要新增一个访问者ConcreteVisitor即可。类图 (Mermaid)«interface»VisitorvisitConcreteElementA(element: ConcreteElementA)visitConcreteElementB(element: ConcreteElementB)«interface»Elementaccept(visitor: Visitor)ConcreteElementAoperationA()accept(visitor: Visitor)ConcreteElementBoperationB()accept(visitor: Visitor)ConcreteVisitorvisitConcreteElementA(element: ConcreteElementA)visitConcreteElementB(element: ConcreteElementB)10. 备忘录模式 (Memento) - 重要程度: 2关键点保存对象内部状态支持恢复优点保存状态而不破坏封装便于实现撤销/恢复功能符合开闭原则缺点消耗较多内存增加类数量状态保存可能影响性能C最佳实现 (详细注释)// 备忘录保存状态classMemento{public:// 构造函数保存状态Memento(intstate):state(state){}// 获取状态intgetState()const{returnstate;}private:intstate;// 状态值};// 发起者创建和恢复备忘录classOriginator{public:// 设置状态voidsetState(intstate){this-statestate;}// 获取状态intgetState()const{returnstate;}// 创建备忘录保存当前状态std::shared_ptrMementocreateMemento(){returnstd::make_sharedMemento(state);}// 恢复状态从备忘录恢复voidrestoreMemento(std::shared_ptrMementomemento){statememento-getState();}private:intstate;// 当前状态};// 负责人管理备忘录classCaretaker{public:// 添加备忘录voidaddMemento(std::shared_ptrMementomemento){mementos.push_back(memento);}// 获取备忘录std::shared_ptrMementogetMemento(intindex){if(index0indexmementos.size()){returnmementos[index];}returnnullptr;}private:std::vectorstd::shared_ptrMementomementos;// 备忘录列表};调用方式intmain(){autooriginatorstd::make_sharedOriginator();autocaretakerstd::make_sharedCaretaker();originator-setState(10);caretaker-addMemento(originator-createMemento());// 保存状态originator-setState(20);originator-restoreMemento(caretaker-getMemento(0));// 恢复到10std::coutCurrent state: originator-getState();// 输出: 10return0;}想想为什么不直接get/set而是用一个类来保存状态可以实现保存多次状态可实现多次撤销恢复到任意状态类图 (Mermaid)Memento-state: intMemento(state: int)getState()Originator-state: intsetState(state: int)getState()createMemento()restoreMemento(memento: Memento)Caretaker-mementos: vectoraddMemento(memento: Memento)getMemento(index: int)11. 解释器模式 (Interpreter) - 重要程度: 1关键点定义语言文法并解释句子优点使语言解释清晰便于添加新解释规则符合开闭原则缺点增加类数量性能可能受影响语法分析复杂C最佳实现 (详细注释)// 表达式接口定义解释方法classExpression{public:virtual~Expression()default;virtualintinterpret()0;// 解释表达式};// 终结符表达式表示终结符classTerminalExpression:publicExpression{public:// 构造函数初始化值TerminalExpression(intvalue):value(value){}// 解释返回值intinterpret()override{returnvalue;// 直接返回值}private:intvalue;// 终结符值};// 非终结符表达式表示复合表达式classNonTerminalExpression:publicExpression{public:// 构造函数初始化左右表达式NonTerminalExpression(std::shared_ptrExpressionleft,std::shared_ptrExpressionright):left(left),right(right){}// 解释组合左右表达式intinterpret()override{returnleft-interpret()right-interpret();// 逻辑组合}private:std::shared_ptrExpressionleft;// 左表达式std::shared_ptrExpressionright;// 右表达式};调用方式intmain(){autoleftstd::make_sharedTerminalExpression(5);autorightstd::make_sharedTerminalExpression(10);autoexpressionstd::make_sharedNonTerminalExpression(left,right);std::coutexpression-interpret();// 输出: 15 (510)return0;}类图 (Mermaid)«interface»Expressioninterpret()TerminalExpression-value: intTerminalExpression(value: int)interpret()NonTerminalExpression-left: Expression-right: ExpressionNonTerminalExpression(left: Expression, right: Expression)interpret()