C++设计模式之策略模式(行为型模式)

最新推荐文章于 2024-08-19 00:45:02 发布
最新推荐文章于 2024-08-19 00:45:02 发布
阅读量383 收藏 1
点赞数
分类专栏： C++设计模式 文章标签： 设计模式 c++ 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cfl927096306/article/details/105853981
版权

学习软件设计，向OO高手迈进！
设计模式(Design pattern)是软件开发人员在软件开发过程中面临的一般问题的解决方案。
这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
是前辈大神们留下的软件设计的"招式"或是"套路"。

什么是策略模式

在本文末尾会给出解释，待耐心看完demo再看定义，相信你会有更深刻的印象

实例讲解

背景

假设我们正在开发一款类似植物大战僵尸的游戏，产品经理告诉我们说：所有僵尸的必要条件是可以动、可以攻击、外观上可以区分就可以了
没问题，写一个抽象类 Character，然后让所有角色（僵尸）继承这个类就可以了。So easy
在这里插入图片描述

Version 1.0

类图
在这里插入图片描述

抽象类

class Character {
public:
    virtual void Move(void) {
        printf("Move\n");
    }

    virtual void Attack(void) {
        printf("Attack\n");
    }

    // 纯虚函数, 由子类实现
    virtual void Display(void) = 0;
};

红头僵尸

class RedHeadZombie : public Character {
public:
    virtual void Display(void) {
        printf("My head is Red\n");
    }
};

绿头僵尸

class GreenHeadZombie : public Character {
public:
    virtual void Display(void) {
        printf("My head is Green\n");
    }
};

main函数

int main(int argc, char *argv[])
{
    Character *p_objRedHeadZombie = new RedHeadZombie();
    Character *p_objGreenHeadZombie = new GreenHeadZombie();

    p_objRedHeadZombie->Move();
    p_objRedHeadZombie->Attack();
    p_objRedHeadZombie->Display();

    p_objGreenHeadZombie->Move();
    p_objGreenHeadZombie->Attack();
    p_objGreenHeadZombie->Display();

    return 0;
}

运行结果

Move
Attack
My head is Red
Move
Attack
My head is Green

在这里插入图片描述

写完了，问题解决，正准备看看新闻资讯的时候，产品经理走过来对我说，需要给每个僵尸设置一个前进速度，而且速度要有区别，不能所有僵尸都一样的。好吧，设置速度嘛，也简单，我在抽象类里面添加一个 Speed 的方法，让红头僵尸和绿头僵尸都分别实现这个方法。也不难，分分种搞定

Version 1.1

类图
在这里插入图片描述

抽象类

class Character {
public:
    ......
    // 纯虚函数, 由子类实现
    virtual void Speed(void) = 0;
};

红头僵尸

class RedHeadZombie : public Character {
public:
    ......
    virtual void Speed(void) {
        printf("speed is 3.0\n");
    }
};

绿头僵尸

class GreenHeadZombie : public Character {
public:
    ......
    virtual void Speed(void) {
        printf("speed is 1.0\n");
    }
};

main函数

int main(int argc, char *argv[])
{
    Character *p_objRedHeadZombie = new RedHeadZombie();
    Character *p_objGreenHeadZombie = new GreenHeadZombie();

    p_objRedHeadZombie->Move();
    p_objRedHeadZombie->Attack();
    p_objRedHeadZombie->Display();
    p_objRedHeadZombie->Speed();

    p_objGreenHeadZombie->Move();
    p_objGreenHeadZombie->Attack();
    p_objGreenHeadZombie->Display();
    p_objGreenHeadZombie->Speed();

    return 0;
}

运行结果

Move
Attack
My head is Red
speed is 3.0
Move
Attack
My head is Green
speed is 1.0

在这里插入图片描述

好吧，该有的速度也有了，提交代码，这下满足你了吧，产品经理这时走过来告诉你，僵尸的攻击方式不能一样的，你怎么让所有僵尸的攻击方式都一样了，这肯定不行的。好像有点道理的样子，那我就改咯。我重写所有的 Attack 方法不就行了

Version 1.2

类图
在这里插入图片描述

红头僵尸

class RedHeadZombie : public Character {
public:
    ......
    virtual void Attack(void) {
        printf("RedHeadZombie's attack\n");
    }
};

绿头僵尸

class GreenHeadZombie : public Character {
public:
    ......
    virtual void Attack(void) {
        printf("GreenHeadZombie's attack\n");
    }
};

main函数，不变

运行结果

Move
RedHeadZombie's attack
My head is Red
speed is 3.0
Move
GreenHeadZombie's attack
My head is Green
speed is 1.0

修改完成，攻击方式也不一样了
在这里插入图片描述

这时候我偷偷瞄了一眼产品经理，发现这货正在向我走过来…此处略掉一万字。反正最后结果就是，他觉得需要再添加两种僵尸（短腿僵尸，无攻击力僵尸），短腿僵尸速度很慢，但是可以远程攻击，无攻击力僵尸（可能是后勤部队，用来给其他僵尸运送军火的）可以移动，但是不能攻击。还是乖乖写吧，继续写两个类 ShortLegZombie（短腿），NoAttackZombie（无攻击力）继承自 Character

Version 1.3

类图
在这里插入图片描述

短腿僵尸

class ShortLegZombie : public Character {
public:
    virtual void Display(void) {
        printf("I'm ShortLegZombie\n");
    }

    virtual void Speed(void) {
        printf("speed is slow\n");
    }

    virtual void Attack(void) {
        printf("ShortLegZombie's attack\n");
    }
};

无攻击力僵尸

class NoAttackZombie : public Character {
public:
    virtual void Display(void) {
        printf("I'm NoAttackZombie\n");
    }

    virtual void Speed(void) {
        printf("speed is 5.0\n");
    }

    virtual void Attack(void) {
        // nothing to do
    }
};

main函数

int main(int argc, char *argv[])
{
    Character *p_objRedHeadZombie = new RedHeadZombie();
    Character *p_objGreenHeadZombie = new GreenHeadZombie();
    Character *p_objShortLegZombie = new ShortLegZombie();
    Character *p_objNoAttackZombie = new NoAttackZombie();

    p_objRedHeadZombie->Move();
    p_objRedHeadZombie->Attack();
    p_objRedHeadZombie->Display();
    p_objRedHeadZombie->Speed();

    p_objGreenHeadZombie->Move();
    p_objGreenHeadZombie->Attack();
    p_objGreenHeadZombie->Display();
    p_objGreenHeadZombie->Speed();

    p_objShortLegZombie->Move();
    p_objShortLegZombie->Attack();
    p_objShortLegZombie->Display();
    p_objShortLegZombie->Speed();

    p_objNoAttackZombie->Move();
    p_objNoAttackZombie->Attack();
    p_objNoAttackZombie->Display();
    p_objNoAttackZombie->Speed();

    return 0;
}

运行结果

Move
RedHeadZombie's attack
My head is Red
speed is 3.0
Move
GreenHeadZombie's attack
My head is Green
speed is 1.0
Move
ShortLegZombie's attack
I'm ShortLegZombie
speed is slow
Move
I'm NoAttackZombie
speed is 5.0

完成了，还好，不算太慢。搞定
在这里插入图片描述

过一会儿，产品经理又走过来和我说，刚刚开会了，他们最后的决定是，需要再多添加下面几种僵尸来增加游戏的可玩性，丰富界面，提高用户可选性，辛苦你们了，最近加加班咯。好吧，一看，四十几种！
在这里插入图片描述

又添加了几个僵尸类，先拿给产品经理看一下。产品经理一看，眼睛微眯，皱着眉头：你这不行呀，你这僵尸怎么速度都是不变的？你遇到障碍物肯定得减速，没有障碍物得加速呀，这个要修改。僵尸在起跑线应该都不具有攻击方式，你这个攻击方式需要修改下。 听你这么一说好像有点道理，当僵尸满足某个条件时修改下速度和攻击方式。但是我现在已经创建十几个僵尸类了，这要修改的工作量有点大呀！而且还有几十种都没写上去呢！

思考改进

在软件开发上，有什么是你可以深信不疑的？
不管当初软件设计得多好，一段时间之后，总是需要成长与改变，否则软件就会“死亡”

能不能优化一下代码，让新建一个僵尸类的时候尽量用几行代码就搞定？而且可以随时修改其行为
这样我们重新梳理下思路：我们编写一个抽象类（Character），让所有的僵尸都继承这个类。速度和攻击方式因为是可以动态改变的，所以我们将需要动态改变的部分抽离出来。我们分别编写 ISpeedBehavior 和 IAttackBehavior 两个接口，将所有的速度和攻击行为都抽离出来。速度和攻击这里暂时写三种吧

设计原则：找出应用中可能需要变化的地方，把它们独立出来，不要和那些不需要变化的代码混在一起

类图
在这里插入图片描述

我们想要产生一个新的红头僵尸实例，并指定特定攻击方式给它，所以干脆让僵尸的行为可以动态的改变好了。换句话说，我们应该在 Character 类中包含设定行为的方法，这样就可以在运行时动态的改变红头僵尸的攻击方式了。我们分别编写 SetAttackBehavior 和 SetSpeedBehavior 两个方法，用于设置僵尸的攻击和速度行为

类图
在这里插入图片描述

回想一下之前的做法：速度行为和攻击行为来自 Character 抽象类的具体实现，或是继承某个接口并由子类自行实现而来，这两种做法都是依赖于“实现”，我们被实现绑得死死的，没办法更改行为（除非写更多代码）
在我们的新设计中，Character 的子类将使用接口（ISpeedBehavior 和 IAttackBehavior）所表示的行为，所以实际的“实现”不会被绑死在 Character 的子类中，换句话说，特定的攻击行为和速度行为的代码写在了实现 ISpeedBehavior 和 IAttackBehavior 的类中，即 SuperAttack 和 FastSpeed 等类中

设计原则：针对接口编程，而不是针对实现编程

接下来我们重新整理下代码

Version 2.0

类图
在这里插入图片描述

IAttackBehavior 接口及其实现类

class IAttackBehavior {
public:
    // 纯虚函数, 由子类实现
    virtual void Attack(void) = 0;
};

class NoAttack : public IAttackBehavior {
public:
    virtual void Attack(void) {
        printf("NoAttack\n");
    }
};

class OrdinaryAttack : public IAttackBehavior {
public:
    virtual void Attack(void) {
        printf("OrdinaryAttack\n");
    }
};

class ReinforceAttack : public IAttackBehavior {
public:
    virtual void Attack(void) {
        printf("ReinforceAttack\n");
    }
};

class SuperAttack : public IAttackBehavior {
public:
    virtual void Attack(void) {
        printf("SuperAttack\n");
    }
};

ISpeedBehavior 接口及其实现类

class ISpeedBehavior {
public:
    // 纯虚函数, 由子类实现
    virtual void Speed(void) = 0;
};

class SlowSpeed : public ISpeedBehavior {
public:
    virtual void Speed(void) {
        printf("SlowSpeed\n");
    }
};

class NormalSpeed : public ISpeedBehavior {
public:
    virtual void Speed(void) {
        printf("NormalSpeed\n");
    }
};

class FastSpeed : public ISpeedBehavior {
public:
    virtual void Speed(void) {
        printf("FastSpeed\n");
    }
};

抽象类

class Character {
public:
    IAttackBehavior *m_pAttackBehavior;
    ISpeedBehavior *m_pSpeedBehavior;

    virtual void Move(void) {
        printf("Move\n");
    }

    virtual void PerformAttack(void) {
        m_pAttackBehavior->Attack();
    }

    virtual void PerformSpeed(void) {
        m_pSpeedBehavior->Speed();
    }

    // 随时调用这个方法改变僵尸的攻击行为
    virtual void SetAttackBehavior(IAttackBehavior *i_pAttackBehavior) {
        m_pAttackBehavior = i_pAttackBehavior;
    }

    // 随时调用这个方法改变僵尸的速度行为
    virtual void SetSpeedBehavior(ISpeedBehavior *i_pSpeedBehavior) {
        m_pSpeedBehavior = i_pSpeedBehavior;
    }

    // 纯虚函数, 由子类实现
    virtual void Display(void) = 0;
};

Character 的子类

class RedHeadZombie : public Character {
public:
    RedHeadZombie(IAttackBehavior *i_pAttackBehavior, ISpeedBehavior *i_pSpeedBehavior) {
        m_pAttackBehavior = i_pAttackBehavior;
        m_pSpeedBehavior = i_pSpeedBehavior;
    }

    virtual void Display(void) {
        printf("My head is Red\n");
    }
};

class GreenHeadZombie : public Character {
public:
    GreenHeadZombie(IAttackBehavior *i_pAttackBehavior, ISpeedBehavior *i_pSpeedBehavior) {
        m_pAttackBehavior = i_pAttackBehavior;
        m_pSpeedBehavior = i_pSpeedBehavior;
    }

    virtual void Display(void) {
        printf("My head is Green\n");
    }
};

class ShortLegZombie : public Character {
public:
    ShortLegZombie(IAttackBehavior *i_pAttackBehavior, ISpeedBehavior *i_pSpeedBehavior) {
        m_pAttackBehavior = i_pAttackBehavior;
        m_pSpeedBehavior = i_pSpeedBehavior;
    }

    virtual void Display(void) {
        printf("I'm ShortLegZombie\n");
    }
};

class NoAttackZombie : public Character {
public:
    NoAttackZombie(IAttackBehavior *i_pAttackBehavior, ISpeedBehavior *i_pSpeedBehavior) {
        m_pAttackBehavior = i_pAttackBehavior;
        m_pSpeedBehavior = i_pSpeedBehavior;
    }

    virtual void Display(void) {
        printf("I'm NoAttackZombie\n");
    }
};

main 函数

int main(int argc, char *argv[])
{
    // 僵尸在起跑线应该都不具有攻击方式, 默认正常速度吧
    IAttackBehavior *p_objNoAttack = new NoAttack();
    ISpeedBehavior *p_objNormalSpeed = new NormalSpeed();

    Character *p_objRedHeadZombie = new RedHeadZombie(p_objNoAttack, p_objNormalSpeed);
    Character *p_objGreenHeadZombie = new GreenHeadZombie(p_objNoAttack, p_objNormalSpeed);
    Character *p_objShortLegZombie = new ShortLegZombie(p_objNoAttack, p_objNormalSpeed);
    Character *p_objNoAttackZombie = new NoAttackZombie(p_objNoAttack, p_objNormalSpeed);

    p_objRedHeadZombie->Move();
    p_objRedHeadZombie->Display();
    p_objRedHeadZombie->PerformAttack();
    p_objRedHeadZombie->PerformSpeed();

    p_objGreenHeadZombie->Move();
    p_objGreenHeadZombie->Display();
    p_objGreenHeadZombie->PerformAttack();
    p_objGreenHeadZombie->PerformSpeed();

    p_objShortLegZombie->Move();
    p_objShortLegZombie->Display();
    p_objShortLegZombie->PerformAttack();
    p_objShortLegZombie->PerformSpeed();

    p_objNoAttackZombie->Move();
    p_objNoAttackZombie->Display();
    p_objNoAttackZombie->PerformAttack();
    p_objNoAttackZombie->PerformSpeed();

    // 动态改变红头僵尸的行为
    p_objRedHeadZombie->SetAttackBehavior(new ReinforceAttack());
    p_objRedHeadZombie->SetSpeedBehavior(new FastSpeed());
    p_objRedHeadZombie->Display();
    p_objRedHeadZombie->PerformAttack();
    p_objRedHeadZombie->PerformSpeed();

    // 动态改变短腿僵尸的行为
    p_objShortLegZombie->SetAttackBehavior(new SuperAttack());
    p_objShortLegZombie->SetSpeedBehavior(new SlowSpeed());
    p_objShortLegZombie->Display();
    p_objShortLegZombie->PerformAttack();
    p_objShortLegZombie->PerformSpeed();

    return 0;
}

运行结果

Move
My head is Red
NoAttack
NormalSpeed
Move
My head is Green
NoAttack
NormalSpeed
Move
I'm ShortLegZombie
NoAttack
NormalSpeed
Move
I'm NoAttackZombie
NoAttack
NormalSpeed
My head is Red
ReinforceAttack
FastSpeed
I'm ShortLegZombie
SuperAttack
SlowSpeed

这下ok了，随便你添加角色，随便你修改速度和攻击行为，我都能随时修改
在这里插入图片描述

策略模式定义

现在，我们来说下什么是策略模式？没错，我们上面的实例用的就是策略模式，分别将程序中变化的部分封装起来，让它们之间可以相互替换（速度和攻击行为）。也就是说策略模式可以让算法的变化独立于使用算法的客户

“有一个”可能比“是一个”更好
“有一个”关系相当有趣：每一个僵尸都有一个 IAttackBehavior 和 ISpeedBehavior，好将攻击和速度委托给它们代为处理
当你将两个类结合起来使用，如同本例一样，这就是组合（composition）。这种做法和“继承”不同的地方在于，僵尸的行为不是继承而来的，而是和适当的行为对象“组合”得来的，这是一个很重要的技巧

设计原则：多用组合，少用继承

策略模式的优缺点

无论哪种模式都有其优缺点，当然我们每次在编写代码的时候需要考虑下其利弊
策略模式的优点：

  1. 提供了快速替换继承关系的办法：本案例中我们能快速的替换僵尸类的速度，攻击类型

  2. 减少代码中的 if else 等判断语句：我们在更换攻击状态的时候不用去判断，当达到某个条件时直接切换攻击实现类就可以了。比如上文中的 NoAttack 变 SuperAttack

  3. 实现的选择：策略模式可以提供不同的实现

策略模式的缺点：

  1. 策略模式会造成很多策略类：上文中的所有速度实现类，攻击实现类……

  2. 客户必须知道所有的策略实现类，必须自行知道所有的策略实现类有何不同，并决定使用哪一个。客户每次新建一个僵尸类的时候必须要知道所有的速度类及攻击类的不同，此时就会暴露出具体的实现问题。

总结

现在我们回顾下刚开始说的策略模式所用到的三个设计原则：

  1. 封装变化。我们将变化的速度和攻击行为封装出来，供动态改变调用
  2. 针对接口、超类编程，不针对实现编程。我们用 ISpeedBehavior 和 IAttackBehavior 接口去代表速度和攻击行为，每种具体的行为类实现其中一个接口
  3. 多用组合，少用继承。组合最大的好处就是具有弹性，给代码维护和需求修改提供极大的便利。最开始我们使用的就是继承的方式，在添加大量僵尸类的时候，代码的维护及修改量将非常大。后面优化过后我们就使用了速度和攻击类及僵尸类的组合去编写代码

其实策略模式在游戏开发中是经常会使用到的。比如说街机西游记，有不同的角色：猪八戒，白龙马，孙悟空。他们都有武器，武器可能被妖怪打掉，也能自己捡起来，还能发不同的招数…
在这里插入图片描述

参考资料

https://blog.csdn.net/qq_32175491/article/details/79465496
Head+First设计模式(中文版).pdf

cfl927096306
关注
专栏目录
设计模式C++实现（2）——策略模式
wuzhekai的专栏
08-06 5万+
软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大
c++设计模式-行为型模式
weixin_43754049的博客
07-21 299
用来对类或对象怎样交互和怎样分配职责进行描述 定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 输出结果： 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。 案例： 命令模式 将一个请求封装为一个对象，从而让我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销操作。命令模式
C++设计模式 | 四种行为型模式——模版方法模式、策略模式、命令模式、观察者模式...
weixin_41017788的博客
02-16 435
模版方法模式 定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 AbstractClass（抽象类）：在抽象类中定义了一系列基本操作，这些基本操作可以是具体的，也可以是抽象的，每一个基本操作对应算法的一个步骤，在其子类中可以重定义或实现这些步骤。同时，在抽象类中实现了一个模板方法(Temp...
C++ 设计模式——策略模式
最新发布
qq_68194402的博客
08-19 1896
引入"策略“设计模式的定义：定义一些列算法类（策略类），将每个算法封装起来，让他们可以互相替换。换句话说，策略模式通常把一系列算法封装到一系列具体策略类中作为抽象策略类的字类，然后根据实际需要适用这些字类。
策略模式（C++）
蜗牛也是牛
01-09 225
策略模式（C++） 　　策略模式：把一系列算法封装起来，使之可以相互替换。这样就可以使算法独立于客户端变化。 　　如我们有很多排序算法，但是在不通的环境中，需要使用不同算法，那就可以定义一个抽象类，提供统一的接口，然后在各个排序算法继承抽象类，并实现该子类的排序算法，再定义一个项目类，通过构造函数传入不同算法类的对象或是模板实例化来表示在不同的项...
C++ 设计模式-策略模式
wangdamingll的博客
12-06 2071
策略模式的介绍和使用
设计模式（C++实现）专题 -- 2.3 行为型模式
NEWPLAN的专栏
07-17 1万+
行为型模式
c++设计模式-行为型模式-策略模式
06-19
c++设计模式-行为型模式-策略模式；qt工程；c++简单源码； 策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于...
C++设计模式之策略模式（Strategy）
12-31
策略模式是一种定义一系列算法的方法，Strategy类层次为Context定义了一系列的可重用的算法或行为， 所有的算法以相同的方式进行调用，减少了算法类之间的耦合 类视图 实现 class Strategy { public: ~Strategy()...
C++设计模式之策略模式
09-04
策略模式是一种设计模式，它允许在运行时动态地选择算法或策略，从而使程序可以根据不同的条件执行不同的行为。这种模式在C++中非常有用，尤其是在处理复杂逻辑和算法切换的场景中。 策略模式的核心思想是将算法...
设计模式C++学习之策略模式（Strategy）
09-07
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在C++中，策略模式通常通过定义一系列算法类并让它们之间可以互换来实现。这些算法类都实现了一个公共接口，使得它们可以被相同的客户端代码调用，而...
c++ 设计模式_行为型设计模式 状态模式
weixin_39560245的博客
11-24 159
author zongemail zongzhe1996@163.com写在前面本文主要是作者在学习设计模式过程中的笔记，主要用来记录思路，文中出现的代码并没有在IDE中进行编译运行，只能保证符合作者的思路，并不是最优解决方案。1.介绍状态设计模式，是一种行为型设计模式，类的行为基于类的状态进行改变。2.意图允许对象在内部状态发生改变的时候，根据状态调整内部行为。3.解决问题对象的行为依...
C++策略设计模式
芒种、的博客
07-16 177
一、策略模式 核心思想：Strategy 模式将逻辑（算法）封装到一个类（Context）里面，通过组合的方式将具体算法的实现在组合对象中实现，再通过委托的方式将抽象接口的实现委托给组合对象实现 #include <iostream> #include <cmath> #include <string> using namespace std; //策略基类 class CashSuper { public: virtual double AcceptMoney(do
c++之策略模式
wx153的博客
03-19 215
c++之策略模式概念图示优缺点优点缺点代码 概念 策略模式是指定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。也就是说这些算法所完成的功能一样，对外的接口一样，只对于不同的“消息”，所产生的行为不同，及面对同一指令，采取的实现方式不同,与c++中多态有一些相似. 就举一个例子,假如上课铃声这一个指令想起,老师会准备备课本,去给学生 上课,学生...
策略模式-C++
Raintoo
04-26 156
#include <iostream> using namespace std; //抽象的策略类 class Strategy { protected: Strategy(){ }; public: virtual void StrategyInterface() = 0; virtual ~Strategy(){ }; }; //具体维护策略类 class Contex...
C++：策略模式
xizi_ghq的博客
04-17 310
策略模式： 定义一系列的算法，将它们封装起来。并且使他们互相可以替换，该模式可以使算法独立于他的客户而实现。 就像工资，不同的工作工资的算法不同，我们不能对工资算法硬性编码，应该是可以自由变化的， Strategy：定义所有支持的算法的公共接口。Context使用这个接口来调用某ConcreteStrategy定义的算法； ConcreteStrategy：实现Strategy接口的具体算法； ...
我所理解的设计模式（C++实现）——策略模式（Strategy Pattern）
热门推荐
十八道胡同的博客专栏
08-24 1万+
每个人都要“交个人所得税”，但是“在美国交个人所得税”和“在中国交个人所得税”就有不同的算税方法。 而策略模式就是对算法进行包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是：“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。 Contex
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cfl927096306

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值