C++设计模式-Strategy策略模式

Strategy模式在数据库开发中的实际应用案例在数据库开发中，常常会遇到需要处理不同种类的数据，并根据不同的数据进行不同的处理的情况。

例如，在一个商场的销售系统中，需要记录商品的销售记录，并对不同种类的商品进行不同的处理，如计算销售额、库存调整等。

这时，我们可以使用设计模式中的Strategy模式来解决这个问题。

Strategy模式是一种行为型设计模式。

它定义了一系列算法，将每个算法都封装起来，并可以相互替换，从而使得算法的变化不会影响到客户端。

在Java语言中，Strategy模式通常通过接口的方式实现。

在数据库开发中，Strategy模式可以用于实现针对不同类型数据的数据访问和处理。

下面我们以一个简单的数据库访问程序为例来说明Strategy模式的应用。

假设我们有一个简单的数据库（使用MySQL）存储了一些学生的信息，如姓名、学号、课程成绩等。

我们需要编写一个Java 程序来访问这个数据库，并能够实现以下功能：1. 根据学号查询学生信息2. 根据姓名查询学生信息3. 计算每个学生的总成绩4. 计算每个学生的平均成绩5. 计算每个学生各门课程的平均成绩首先，我们定义一个接口DataAccess，用于定义访问数据库的方法：```public interface DataAccess {public Student findStudentByNumber(String number);public List<Student> findStudentsByName(String name);public double calculateTotalScore(Student student);public double calculateAverageScore(Student student);public Map<String, Double> calculateAverageScores(Student student);}```然后，我们定义一个MySQLDataAccess类，实现DataAccess 接口，并实现以上5个方法：```public class MySQLDataAccess implements DataAccess {// 实现findStudentByNumber方法public Student findStudentByNumber(String number) {// 执行查询操作，返回查询结果}// 实现findStudentsByName方法public List<Student> findStudentsByName(String name) {// 执行查询操作，返回查询结果}// 实现calculateTotalScore方法public double calculateTotalScore(Student student) {// 计算总成绩，返回计算结果}// 实现calculateAverageScore方法public double calculateAverageScore(Student student) {// 计算平均成绩，返回计算结果}// 实现calculateAverageScores方法public Map<String, Double> calculateAverageScores(Student student) {// 计算各门课程平均成绩，返回计算结果}}```现在，我们可以在客户端调用MySQLDataAccess类的实例来实现以上功能。

context在策略模式中的作用在软件开发中，策略模式是一种常见的设计模式。

它允许在运行时根据不同的情况选择不同的算法或行为。

在策略模式中，context （上下文）起着重要的作用，它负责将具体的算法或行为委托给对应的策略对象。

本文将详细探讨context在策略模式中的作用和重要性。

我们来了解一下策略模式的基本概念和结构。

策略模式由三个核心组件组成：context（上下文）、strategy（策略）和具体策略（Concrete Strategy）。

context是与客户端交互的主要对象，它根据不同的情况选择合适的策略对象，并将具体的任务委托给策略对象来完成。

strategy是一个接口或抽象类，定义了策略对象的共同接口。

具体策略是实现了策略接口的具体类，封装了不同的算法或行为。

在策略模式中，context起着重要的作用。

它负责维护对策略对象的引用，并在运行时根据不同的情况选择合适的策略对象。

通过使用context，客户端可以将具体的任务委托给策略对象来完成，而无需关心具体的实现细节。

这种将任务委托给策略对象的方式使得策略模式具有很好的扩展性和灵活性。

context在策略模式中的作用可以总结为以下几点：1. 封装了策略的选择和使用过程：context负责根据不同的情况选择合适的策略对象，并将具体的任务委托给策略对象来完成。

这样一来，客户端只需要与context交互，无需关心具体的策略选择和实现细节，使得代码更加简洁和易于维护。

2. 提供了灵活的策略切换机制：由于context将具体的任务委托给策略对象来完成，因此在运行时可以根据需要动态切换策略。

这种灵活的策略切换机制使得系统更加可扩展和可定制，能够满足不同的需求。

3. 实现了策略的复用：通过将策略封装在独立的策略对象中，可以在不同的上下文中复用相同的策略。

这种策略的复用可以减少重复的代码，提高代码的可维护性和可重用性。

4. 支持了开闭原则：策略模式符合开闭原则，即对扩展开放，对修改关闭。

⼤话设计模式——C++版本⼀、什么是设计模式设计模式（Design pattern）是⼀套被反复使⽤、多数⼈知晓的、经过分类编⽬的、代码设计经验的总结。

使⽤设计模式是为了可重⽤代码、让代码更容易被他⼈理解、保证代码可靠性。

毫⽆疑问，设计模式于⼰于他⼈于系统都是多赢的，设计模式使代码编制真正⼯程化，设计模式是软件⼯程的基⽯，如同⼤厦的⼀块块砖⽯⼀样。

项⽬中合理的运⽤设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每⼀个模式描述了⼀个在我们周围不断重复发⽣的问题，以及该问题的核⼼解决⽅案，这也是它能被⼴泛应⽤的原因。

简单说：模式：在某些场景下，针对某类问题的某种通⽤的解决⽅案。

场景：项⽬所在的环境问题：约束条件，项⽬⽬标等解决⽅案：通⽤、可复⽤的设计，解决约束达到⽬标。

⼆、设计模式的三个分类创建型模式：对象实例化的模式，创建型模式⽤于解耦对象的实例化过程。

结构型模式：把类或对象结合在⼀起形成⼀个更⼤的结构。

⾏为型模式：类和对象如何交互，及划分责任和算法。

如下图所⽰：三、各分类中模式的关键点四、概说23种设计模式1.单例模式单例模式，它的定义就是确保某⼀个类只有⼀个实例，并且提供⼀个全局访问点。

单例模式具备典型的3个特点：1、只有⼀个实例。

2、⾃我实例化。

3、提供全局访问点。

因此当系统中只需要⼀个实例对象或者系统中只允许⼀个公共访问点，除了这个公共访问点外，不能通过其他访问点访问该实例时，可以使⽤单例模式。

单例模式的主要优点就是节约系统资源、提⾼了系统效率，同时也能够严格控制客户对它的访问。

也许就是因为系统中只有⼀个实例，这样就导致了单例类的职责过重，违背了“单⼀职责原则”，同时也没有抽象类，所以扩展起来有⼀定的困难。

其UML结构图⾮常简单，就只有⼀个类，如下图：2.⼯⼚⽅法模式作为抽象⼯⼚模式的孪⽣兄弟，⼯⼚⽅法模式定义了⼀个创建对象的接⼝，但由⼦类决定要实例化的类是哪⼀个，也就是说⼯⼚⽅法模式让实例化推迟到⼦类。

设计模式中的多态——策略模式详解⽬录策略模式和java语⾔的多态特性有些像。

java的多态特性允许我们⾯向接⼝编程,不⽤关⼼接⼝的具体实现。

接⼝所指向的实现类,以及通过接⼝调⽤的⽅法的具体⾏为可以到运⾏时才绑定。

这么做最⼤的好处是在尽可能实现代码复⽤的前提下更好地应对具体实现类的变化。

⽐如我想增加⼀种接⼝的实现或者修改原有实现类的某个⾏为,那我⼏乎不⽤修改任何客户端代码。

策略模式可以说正是这种思想在设计模式上的运⽤。

它可以使我们更好的复⽤代码,同时使程序结构设计更有弹性,更好的应对变化。

2. 策略模式详解2.1 策略模式定义策略模式定义了⼀系列算法,并将每⼀个算法封装起来，⽽且使它们还可以相互替换。

策略模式让算法独⽴于使⽤它的客户端⽽独⽴的变化。

可以使⽤多态进⾏类⽐来理解策略模式的定义。

⼀系列算法可以理解成接⼝的不同实现类,因为不同实现类都实现了相同的接⼝,因⽽它们也可以相互替换。

策略模式让算法独⽴于客户端⽽变化与接⼝的实现类可以独⽴于使⽤接⼝的客户端变化类似。

2.2 策略模式的UML类图从UML类图上可以看出,策略模式中主要有3个⾓⾊抽象策略接⼝上图中的Strategy即抽象策略接⼝,接⼝中定义了抽象的策略算法algorithm()。

具体的策略实现类上图中的StrategyA和StrategyB即具体的策略实现。

不同的策略实现类都实现了抽象策略接⼝,并重写了其抽象策略⽅法。

因为都实现了相同的策略接⼝，因⽽算法可以相互替换,并且可以动态的改变具体的算法实现。

封装策略的上下⽂环境上图中的Context即策略的上下⽂环境。

它屏蔽了⾼层模块对策略算法的直接访问,封装了可能存在的变化。

⽽且提供了修改Strategy的setter⽅法,可以动态的改变算法的具体实现。

3.策略模式的优点我们可以结合使⽤策略模式的例⼦并与其它实现⽅案进⾏对⽐来看看策略模式到底有什么好处3.1 ⼀个使⽤策略模式的例⼦定义⼀个汽车类Car。

设计模式之策略模式（Strategy）详解及代码⽰例⼀、策略模式的定义 策略（Strategy）模式的定义：该模式定义了⼀系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使⽤算法的客户。

策略模式属于对象⾏为模式，它通过对算法进⾏封装，把使⽤算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进⾏管理。

⼆、策略模式优缺点 策略模式的主要优点如下。

多重条件语句不易维护，⽽使⽤策略模式可以避免使⽤多重条件转移语句。

符合开闭原则，可以在不修改原代码的情况下，灵活增加新算法。

算法使⽤和实现隔离分离，提⾼算法的保密性和安全性。

策略模式提供了⼀系列的可供重⽤的算法族，恰当使⽤继承可以把算法族的公共代码转移到⽗类⾥⾯，从⽽避免重复的代码。

策略模式可以提供相同⾏为的不同实现，客户可以根据不同时间或空间要求选择不同的。

其主要缺点如下。

客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。

策略模式造成很多的策略类。

三、策略模式的结构与实现 策略模式是准备⼀组算法，并将这组算法封装到⼀系列的策略类⾥⾯，作为⼀个抽象策略类的⼦类。

策略模式的重⼼不是如何实现算法，⽽是如何组织这些算法，从⽽让程序结构更加灵活，具有更好的维护性和扩展性，现在我们来分析其基本结构和实现⽅法。

策略模式的主要⾓⾊如下。

抽象策略（Strategy）类：定义了⼀个公共接⼝，各种不同的算法以不同的⽅式实现这个接⼝，环境⾓⾊使⽤这个接⼝调⽤不同的算法，⼀般使⽤接⼝或抽象类实现。

具体策略（Concrete Strategy）类：实现了抽象策略定义的接⼝，提供具体的算法实现。

环境（Context）类：持有⼀个策略类的引⽤，最终给客户端调⽤。

其结构图如图所⽰： 代码实现如下：public class StrategyPattern{public static void main(String[] args){Context c=new Context();Strategy s=new ConcreteStrategyA();c.setStrategy(s);c.strategyMethod();System.out.println("-----------------");s=new ConcreteStrategyB();c.setStrategy(s);c.strategyMethod();}}//抽象策略类interface Strategy{public void strategyMethod(); //策略⽅法}//具体策略类Aclass ConcreteStrategyA implements Strategy{public void strategyMethod(){System.out.println("具体策略A的策略⽅法被访问！");}}//具体策略类Bclass ConcreteStrategyB implements Strategy{public void strategyMethod(){System.out.println("具体策略B的策略⽅法被访问！");}}//环境类class Context{private Strategy strategy;public Strategy getStrategy(){return strategy;}public void setStrategy(Strategy strategy){this.strategy=strategy;}public void strategyMethod(){strategy.strategyMethod();}} 测试结果如下：具体策略A的策略⽅法被访问！-----------------具体策略B的策略⽅法被访问！ 如下补充⼀个促销策略模式：interface PromotionStrategy {void doPromotion();}class FanXianPromotionStrategy implements PromotionStrategy{@Overridepublic void doPromotion() {System.out.println("返现促销");}}class LiJianPromotionStrategy implements PromotionStrategy {@Overridepublic void doPromotion() {System.out.println("⽴减促销");}}class ManJianPromotionStrategy implements PromotionStrategy{@Overridepublic void doPromotion() {System.out.println("满减促销");}}class PromotionActivity {private PromotionStrategy promotionStrategy;public PromotionActivity(PromotionStrategy promotionStrategy) {this.promotionStrategy = promotionStrategy;}public void executePromotionStrategy(){promotionStrategy.doPromotion();}}public class Test {public static void main(String[] args) {PromotionActivity promotionActivity618 = new PromotionActivity(new LiJianPromotionStrategy());PromotionActivity promotionActivity1111 = new PromotionActivity(new FanXianPromotionStrategy());promotionActivity618.executePromotionStrategy();promotionActivity1111.executePromotionStrategy();}}四、策略模式的应⽤场景 策略模式在很多地⽅⽤到，如 Java SE 中的容器布局管理就是⼀个典型的实例，Java SE 中的每个容器都存在多种布局供⽤户选择。

无意中，从网上下到一本电子书《24种设计模式介绍与6大设计原则》，很好奇这里有24种设计模式，印象中GOF写的《设计模式》（Design Patterns），好像只有23种吧。

运行起来一看，还真挺吸引咱的，里面提到的例子都很有趣。

很感谢作者写出这样好的例子来，我的目的是把作者提到的例子用C++来实现。

写这本书的作者是：cbf4life，更详细的内容及说明可以参考原作者博客：blogs.co m。

这里只进行简单提示和实现编码。

1.1.解释main()，赵云CContext，锦囊IStrategy，策略接口CBackDoor，策略之一CGivenGreenLight，策略之二CBlockEnemy，策略之三说明：一个策略放到一个锦囊里。

当用的时候，找到这个锦囊，从锦囊里拿出策略来使用。

注意：锦囊只是简单的装载和调用策略，锦囊里没有逻辑。

策略会有更大的自主权，运行更多的逻辑。

看代码：//Context.h#pragma once#include "IStrategy.h"class CContext{public:CContext(IStrategy *pStrategy);~CContext(void);void Operate(void);private:IStrategy *m_pStrategy;};//Context.cpp#include "StdAfx.h"#include "Context.h"CContext::CContext(IStrategy *pStrategy) {this->m_pStrategy = pStrategy;}CContext::~CContext(void){delete this->m_pStrategy;}void CContext::Operate(void){this->m_pStrategy->Operate();}//IStrategy.h#pragma onceclass IStrategy{public:IStrategy(void);virtual ~IStrategy(void);virtual void Operate(void) = 0; };//BackDoor.h#pragma once#include "istrategy.h"class CBackDoor :public IStrategy{public:CBackDoor(void);~CBackDoor(void);void Operate(void);};//BackDoor.cpp#include "StdAfx.h"#include "BackDoor.h"#include <iostream>using std::cout;using std::endl;CBackDoor::CBackDoor(void){}CBackDoor::~CBackDoor(void) {}void CBackDoor::Operate(void) {cout << "找乔国老帮忙，让吴国太给孙权施加压力" << endl; }//GivenGreenLight.h#pragma once#include "istrategy.h"class CGivenGreenLight :public IStrategy{public:CGivenGreenLight(void);~CGivenGreenLight(void);void Operate(void);};//GivenGreenList.cpp#include "StdAfx.h"#include "GivenGreenLight.h"#include <iostream>using std::cout;using std::endl;CGivenGreenLight::CGivenGreenLight(void){}CGivenGreenLight::~CGivenGreenLight(void){}void CGivenGreenLight::Operate(void){cout << "求吴国太开个绿灯，放行！" << endl; }//BlockEnemy.h#pragma once#include "istrategy.h"class CBlockEnemy :public IStrategy{public:CBlockEnemy(void);~CBlockEnemy(void);void Operate(void);};//BlockEnemy.cpp#include "StdAfx.h"#include "BlockEnemy.h"#include <iostream>using std::cout;using std::endl;CBlockEnemy::CBlockEnemy(void){}CBlockEnemy::~CBlockEnemy(void){}void CBlockEnemy::Operate(){cout << "孙夫人断后，挡住追兵" << endl;}//Strategy.cpp#include "stdafx.h"#include "Context.h"#include "BackDoor.h"#include "GivenGreenLight.h"#include "BlockEnemy.h"#include <iostream>using std::cout;using std::endl;int _tmain(int argc, _TCHAR* argv[]){CContext *pContext;cout << "\14\n\n\n\n\17" << endl;cout << "----------刚刚到吴国的时候拆第一个----------" << endl;pContext = new CContext(new CBackDoor());pContext->Operate();delete pContext;cout << "\14\n\n\n\n\17" << endl;cout << "----------刘备乐不思蜀了，拆第二个了----------" << endl;pContext = new CContext(new CGivenGreenLight());pContext->Operate();delete pContext;cout << "\14\n\n\n\n\17" << endl;cout << "----------孙权的小兵追了，咋办？拆第三个----------" << endl;pContext = new CContext(new CBlockEnemy());pContext->Operate();delete pContext;_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);_CrtDumpMemoryLeaks();return 0;}一个锦囊只能装一个妙计，赵云可以有多个锦囊。

《软件设计模式(一)》在线平时作业2在不破坏类封装性的基础上，使得类可以同不曾估计到的系统进行交互。

主要体现在（）。

A:外观模式（Facade）B:装饰模式(Decorator)C:策略模式（Strategies）D:桥接模式(Bridge)参考选项：D对象组合的优点表述不当的是（）A:容器类仅能通过被包含对象的接口来对其进行访问B:“墨盒”复用，封装性好，因为被包含对象的内部细节对外是不可见C:通过获取指向其他的具有相同类型的对象引用，可以在运行期间动态地定义（对象的）组合D:造成极其严重的依赖关系参考选项：D关于模式适用性，（）不适合使用桥接（ Bridge ）模式。

A:类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充，这时Bridge 模式使用户可以对不同的抽象接口和实现部分进行组合，并分别对它们进行扩充B:用户不希望在抽象和它的实现部分之间有一个固定的绑定关系，例如，这种情况可能是因为在程序运行时刻实现部分应可以被选择或者切换C:对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译D:客户程序与抽象类的实现部分之间存在着很大的依赖性参考选项：D关于模式适用性，以下（）适合使用组合（Composite）模式。

A:用户想使用一个已经存在的类，而它的接口不符合用户的需求B:当一个类的实例只能有几个不同状态组合中的一种时C:用户想表示对象的部分－整体层次结构D:一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为参考选项：C关于模式适用性，不适合使用适配器（ Adapter ）模式的是（）。

A:用户想、使用一个已经存在的类，而它的接口不符合用户的需求B:用户想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作C:用户想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。

对象适配器可以适配它的父类接口1。

C++设计模式之策略模式（Strategy）策略模式将不同算法的逻辑抽象接⼝封装到⼀个类中，通过组合和多态结合的⽅式来进⾏不同算法具体的实现。

作⽤策略模式是⼀种定义⼀系列算法的⽅法，Strategy类层次为Context定义了⼀系列的可重⽤的算法或⾏为，所有的算法以相同的⽅式进⾏调⽤，减少了算法类之间的耦合类视图实现class Strategy{public:~Strategy();virtual void AlgrithmInterface()=0;protected:Strategy();};class ConcreteStrategyA : public Strategy{public:ConcreteStrategyA();~ConcreteStrategyA();virtual void AlgrithmInterface();};class ConcreteStrategyB : public Strategy{public:ConcreteStrategyB();~ConcreteStrategyB();virtual void AlgrithmInterface();};class Context{public:Context(Strategy*);~Context();void DoAction();private:Strategy* _strategy;};int main(){//策略A与B可替换Strategy* pStra = new ConcreteStrategyA();Context* pCon = new Context(pStra);pCon->DoAction();pStra = new ConcreteStrategyB();pCon = new Context(pStra);pCon->DoAction();return 0;}Strategy模式和Template模式的根本区别是Strategy通过组合⽅式实现算法（实现）的异构，⽽Template模式则采取的是继承的⽅式，这两个模式的区别也是继承和组合两种实现接⼝重⽤的⽅式的区别。

24种设计模式Factory Pattern(⼯⼚模式)：1. 创建对象的接⼝，封装对象的创建；2. 使具体化类的⼯作延迟到⼦类中。

（维护⼀类对象）AbstractFactory Pattern(抽象⼯⼚模型)：该模式将⼀组对象的创建封装到⼀个⽤于创建对象的类中。

（解决的问题：要创建⼀组或者相互依赖的对象）。

Singleton Pattern(单例模式)：该模式在⾯向纯粹的⾯向对象的范式中⽤于创建唯⼀的实例，值得注意的是Singleton不能被实例化，因此将其构造函数声明为protected或private类型。

Singleton Pattern经常与Factory Pattern结合使⽤，因为Factory对象只能有⼀个。

Builder Pattern(创建者模式)：将⼀个复杂的对象的构建与它的表⽰分离，使得同样的构建构成可以创建不同的表⽰。

如建筑师画图纸，⽽⼯⼈建造房屋。

Prototype Pattern(原型模式)：提供⼀个通过已存在对象进⾏新对象创建的接⼝（clone）。

（浅拷贝和深拷贝）Bridge Pattern(桥梁模式)：将抽象部分与实现部分分开实现，使他们都可以独⽴地变化，并使⽤组合的⽅式将多维度的抽象⽅法联系在⼀起。

⽐如咖啡分⼩杯、中杯、⼤杯以及加奶和不加奶，则抽象部分为：⼩杯、中杯、⼤杯，⾏为为：加奶和不加奶。

Adapter Pattern(适配器模式)：适配就是由“源”到“⽬标”的适配，⽽当中链接两者的关系就是适配器。

它负责把“源”过度到“⽬标”。

将⼀个类的接⼝转换成客户希望的另外⼀个接⼝。

Adapter模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的那些类可以⼀起⼯作。

适配器模式分为两种：①⾯向类的设计模式；②⾯向对象的设计模式。

①⾯向类的适配器：该模式使⽤继承和接⼝实现的⽅式复⽤需要适配器的类。

②⾯向对象的适配器：该模式使⽤组合的⽅式实现需要复⽤的类。

Decorator模式（装饰模式）：动态地给⼀个对象添加⼀些额外的职责。