设计模式C++学习笔记之一(Strategy策略模式)

1.设计模式的原理? (C)C. 面向接口编程2. 以下对"开-闭"原则的一些描述错误的是?(A)A. "开-闭"原则与"对可变性的封装原则"没有相似性.3.以下属于创建型模式是? (A)B.BUILDER（生成器）C. PROTOTYPE（原型）D.SINGLETON（单件）4.以下属于结构型模式是? (D)COMPOSITE（组合） B. ADAPTER（适配器）B.FLYWEIGHT（享元）5.以下属于行为型模式是? (D )6. COMMAND（命令）7. STRATEGY(策略)8. MEMENTO（备忘录）/*23模式意图*/6.以下意图那个是用来描述ABSTRACT FACTORY（抽象工厂)?(A)A.提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

7.以下意图那个是用来描述BUILDER（生成器）?(B)将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

8.以下意图那个是用来描述FACTORY METHOD（工厂方法）?(C)C.定义一个用于创建对象的接口，让子类决定实例化哪一个类。

该模式使一个类的实例化延迟到其子类。

9.以下意图那个是用来描述PROTOTYPE（原型）?(D)D.用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

10.以下意图那个是用来描述SINGLETON（单件）?(B)B.保证一个类仅有一个实例，并提供一个访问它的全局访问点。

11.以下意图那个是用来描述ADAPTER（适配器）?(A)A.将一个类的接口转换成客户希望的另外一个接口。

本模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

12.以下意图那个是用来描述BRIDGE（桥接）?(B)B.将抽象部分与它的实现部分分离，使它们都可以独立地变化。

13.以下意图那个是用来描述COMPOSITE（组合）?(C)C.将对象组合成树形结构以表示“部分-整体”的层次结构。

设计模式之策略模式浅谈以及简单例⼦设计模式之策略模式策略模式定义了算法类，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独⽴于使⽤算法的客户。

策略模式是对算法的包装，是把使⽤的责任和算法本⾝分割开来，委派给不同的对象管理。

策略模式通常把⼀个系列的算法包装到⼀系列的策略类⾥⾯，作为⼀个抽象策略类的⼦类。

策略模式涉及到三个⾓⾊：环境（Context）⾓⾊：持有⼀个Strategy的引⽤，也称策略上下⽂。

抽象策略（Strategy）⾓⾊：这是⼀个抽象⾓⾊，通常使⽤抽象类或者接⼝来实现。

此⾓⾊给出所有的具体策略类所需要的接⼝。

具体策略（ConcreteStrategy）⾓⾊：此⾓⾊包装了所有的算法和⾏为。

Eg：商场搞促销，促销⽅式有打折、满100减50等。

在本例中，抽象策略⾓⾊⽤⼀个结果实现，接⼝中有⼀个计算价格的⽅法。

接⼝实现如下：1namespace Strategy_Pattern23 {45///<summary>67///策略接⼝89///</summary>1011interface IPromotion1213 {1415///<summary>1617///根据原价和策略计算新价格1819///</summary>2021///<param name="originalPrice">原价</param>2223///<returns></returns>2425double GetPrice(double originalPrice);2627 }2829 }具体策略⾓⾊有两个，分别表⽰打折类和满100减50，都实现策略接⼝。

打折类实现如下：1 using System;2345 namespace Strategy_Pattern67 {89 /// <summary>1011 /// 打折策略类1213 /// </summary>1415 class Discount : IPromotion1617 {181920212223 #region Public Methods2425 public double GetPrice(double originalPrice) 2627 {2829 Console.WriteLine("打⼋折");3031 return originalPrice * 0.8;3233 }3435 #endregion36373839 }4041 }满100减50类实现如下：/// <summary>/// 返现策略类：满100返50/// </summary>class MoneyBack : IPromotion{#region Public Methodspublic double GetPrice(double originalPrice){Console.WriteLine("满100返50");return originalPrice - (int)originalPrice / 100 - 50; }#endregion}环境（Context）⾓⾊类如下：/// <summary>/// 策略上下⽂类/// </summary>class PromotionContext{#region Fieldsprivate IPromotion m_promotion = null;#endregion#region Constructorspublic PromotionContext(IPromotion iPromotion){this.m_promotion = iPromotion;}#endregion#region Public Methods/// <summary>/// 默认策略⽅法/// </summary>/// <param name="originalPrice"></param>/// <returns></returns>public double GetPrice(double originalPrice){if (this.m_promotion == null){this.m_promotion = new Discount();}return this.m_promotion.GetPrice(originalPrice);}/// <summary>/// 更改策略的⽅法/// </summary>/// <param name="iPromotion"></param>public void ChangePromotion(IPromotion iPromotion){this.m_promotion = iPromotion;}#endregion}然后再主类中调⽤相应的策略，主类实现如下：class Program{static void Main(string[] args){//默认策略：打⼋折的策略PromotionContext promotionContext=new PromotionContext(null);Console.WriteLine(promotionContext.GetPrice(300));//更改策略：满100减50的策略promotionContext.ChangePromotion(new MoneyBack()); Console.WriteLine(promotionContext.GetPrice(100));Console.ReadLine();}}。

设计模式中的多态——策略模式详解⽬录策略模式和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 中的每个容器都存在多种布局供⽤户选择。

23种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。

这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。

目前，常用的设计模式有23种。

下面，我们来详细介绍一下这23种设计模式。

1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。

在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。

2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。

它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。

3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。

它可以生成一系列相关或相互依赖的对象实例。

具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。

4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。

它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。

5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。

一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。

6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。

具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。

7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。

具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。

8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。

无意中，从网上下到一本电子书《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;}一个锦囊只能装一个妙计，赵云可以有多个锦囊。