MCGA: Make Code GREAT Again系列之设计模式关卡一Template Method

已于 2024-05-01 11:57:06 修改
阅读量1.6k 收藏 26
点赞数 52
分类专栏： 设计模式系列 文章标签： 设计模式 模板方法模式
于 2024-05-01 11:35:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqpz8848/article/details/138369374
版权

Template Method模板设计模式

Template Method 模板模式的核心设计原则

所有设计模式的代码以及文档都放在github中，这是我的github链接，MCGA: Make Code GREAT Again 欢迎大家收藏下载~

Template Method 模式的核心在于定义一个操作中的算法的框架，允许子类在不改变算法结构的情况下，重定义算法的某些特定步骤。这种模式主要用来实现代码的复用及扩展的同时，还可以提供固定的算法架构。

1.核心设计原则

  1. 封装不变部分，扩展可变部分：
    Template Method 模式通过把不变的行为搬移到超类，去除子类中的重复代码来体现封装。可变的行为则保留在子类中实现，提供扩展的可能性。

  2. 利用继承推迟决策：
    通过继承，子类可以选择如何实现算法中的某些步骤，即在超类中定义非具体操作（通过虚函数实现），这样的设计让子类可以自主决定如何实现这些步骤。

  3. 提供框架和挂钩（hooks）：
    Template Method 不仅定义算法的框架，还可以提供挂钩来让子类“挂入”或改变算法的具体内容，而不改变算法的结构。

2.使用情景

Template Method 模式适用于以下情况：

  1. 多个类有相似的行为，但具体实现细节有所不同：
    当不同的实现有着部分相同的步骤时，可以使用 Template Method 模式来提取这些共通的步骤到一个公共父类中，通过抽象方法让子类实现具体的细节。我们可以查看这个例子：

class HttpRequest {
public:
    virtual ~HttpRequest() {}

    // 模板方法定义了请求的固定流程
    void sendRequest() {
        prepare();         // 准备请求
        send();            // 发送请求
        handleResponse();  // 处理响应
    }

protected:
    virtual void prepare() = 0;        // 准备请求的细节由子类实现
    virtual void send() = 0;           // 发送请求的细节由子类实现
    virtual void handleResponse() = 0; // 处理响应的细节由子类实现
};

在这里我们有一个http请求，需要进行准备，发送以及处理响应，但是具体的请求类型有很多不同，因此我们可以在子类中进行实现：

// 子类实现具体请求类型
class GetRequest : public HttpRequest {
protected:
    void prepare() override {
        std::cout << "Preparing GET request..." << std::endl;
    }

    void send() override {
        std::cout << "Sending GET request..." << std::endl;
    }

    void handleResponse() override {
        std::cout << "Handling response for GET request..." << std::endl;
    }
};

class PostRequest : public HttpRequest {
protected:
    void prepare() override {
        std::cout << "Preparing POST request..." << std::endl;
    }

    void send() override {
        std::cout << "Sending POST request..." << std::endl;
    }

    void handleResponse() override {
        std::cout << "Handling response for POST request..." << std::endl;
    }
};

最终我们在main函数中只需要调用sendRqeust即可实现不同类型的请求处理：

int main() {
    HttpRequest* getRequest = new GetRequest();
    getRequest->sendRequest();  // 执行GET请求流程

    HttpRequest* postRequest = new PostRequest();
    postRequest->sendRequest(); // 执行POST请求流程

    delete getRequest;
    delete postRequest;
    return 0;
}
  1. 代码复用：
    当多个类的方法中包含重复的代码时，Template Method 模式是一种将共有代码移动到单一位置，防止代码冗余的策略。
    假设我们现在有一个报表，我们需要生成报表，包括获取数据，处理数据，格式化以及打印四个步骤，那么我们可能有许多种不同类型的报表，那么针对具体的报表，我们都可以用统一的处理流程：
class Report {
public:
    virtual ~Report() {}

    // 模板方法定义了报表生成的流程
    void generate() {
        fetchData();        // 获取数据
        processData();      // 处理数据
        formatReport();     // 格式化报表
        printReport();      // 打印报表
    }

protected:
    virtual void fetchData() = 0;        // 获取数据由子类实现
    virtual void processData() = 0;      // 处理数据由子类实现
    virtual void formatReport() = 0;     // 格式化报表由子类实现
    virtual void printReport() = 0;      // 打印报表由子类实现
};

对于具体的不同报表类，我们都可以去进行继承使用：

// 具体报表类：SalesReport
class SalesReport : public Report {
protected:
    void fetchData() override {
        std::cout << "Fetching sales data..." << std::endl;
    }

    void processData() override {
        std::cout << "Processing sales data..." << std::endl;
    }

    void formatReport() override {
        std::cout << "Formatting sales report..." << std::endl;
    }

    void printReport() override {
        std::cout << "Printing sales report..." << std::endl;
    }
};

// 具体报表类：InventoryReport
class InventoryReport : public Report {
protected:
    void fetchData() override {
        std::cout << "Fetching inventory data..." << std::endl;
    }

    void processData() override {
        std::cout << "Processing inventory data..." << std::endl;
    }

    void formatReport() override {
        std::cout << "Formatting inventory report..." << std::endl;
    }

    void printReport() override {
        std::cout << "Printing inventory report..." << std::endl;
    }
};

int main() {
    Report* salesReport = new SalesReport();
    salesReport->generate(); // 生成销售报表

    Report* inventoryReport = new InventoryReport();
    inventoryReport->generate(); // 生成库存报表

    delete salesReport;
    delete inventoryReport;
    return 0;
}

Template Method模式可以将报表生成的公共流程定义在一个父类中，并且在子类实现具体的细节，从而避免代码冗余。

  1. 控制子类扩展：
    你可以在模板方法中不仅定义抽象的操作，也定义具体的操作和顺序，它定义了一个算法的骨架。通过这种方式，可以准确控制子类的扩展。

  2. 关键过程的固定算法：
    在需要固定算法结构，同时允许算法具有一定的灵活性和适应性时，可以使用 Template Method 模式。例如，在游戏中，游戏的启动、进行和结束是固定的，但具体如何启动、进行和结束则可以由具体的游戏来决定。

3.示例中的应用

在代码示例中：

#include <iostream>
#include <memory>
#include <utility>
using namespace std;
// 抽象基类
class Game {
public:
    // 定义算法的骨架，这一个play的方法是固定不变的
    void play() {
        start();
        playing();
        end();
    }
    virtual ~Game() {}
protected:
    virtual void start() = 0;   // 交给子类实现
    virtual void playing() = 0; // 交给子类实现
    virtual void end() = 0;     // 交给子类实现
};


// 象棋类
class Chess : public Game {
protected:
    void start() override {
        cout << "Chess start" << endl;
    }
    void playing() override {
        cout << "Chess playing" << endl;
    }
    void end() override {
        cout << "Chess end" << endl;
    }
};

// 扑克类
class Poker : public Game {
protected:
    void start() override {
        cout << "Poker start" << endl;
    }
    void playing() override {
        cout << "Poker playing" << endl;
    }
    void end() override {
        cout << "Poker end" << endl;
    }
};

int main() {
    // 使用智能指针，自动释放资源
    shared_ptr<Game> chess = make_shared<Chess>();
    chess->play();

    shared_ptr<Game> poker = make_shared<Poker>();
    poker->play();

    return 0;
}

如果象棋或者扑克想添加新的功能该怎么办呢？那么我们就需要一个更加固定的算法框架：

下面是新修改之后的框架：

#include <iostream>
#include <memory>
#include <utility>

using namespace std;


class Game {
public:
    // 模板方法
    void play() {
         start();
         // 此处为新添加的功能
         if(addNewGameFeature()) {
            newFeature();
         }
         playing();
         end();

    }

    virtual ~Game() = default;

protected:
    virtual void start() = 0;
    virtual void end() = 0;
    virtual void playing() = 0;

    // 此处为新添加的功能
    virtual bool addNewGameFeature() {
        return false;
    }
    // 此处为新添加的功能
    virtual void newFeature() {
        cout << "new feature" << endl;
    }

};


// 象棋类
class Chess : public Game {
protected:
    void start() override {
        std::cout << "Chess Game Started." << std::endl;
    }

    void playing() override {
        std::cout << "Playing Chess Game." << std::endl;
    }

    void end() override {
        std::cout << "Chess Game Finished." << std::endl;
    }

    bool addNewGameFeature() override {
        return true; // 特定情况下我们可能想加入新功能
    }

    void newFeature() override {
        std::cout << "New Chess Strategy Tips." << std::endl;
    }
};

// 扑克类
class Poker : public Game {
protected:
    void start() override {
        cout << "Poker start" << endl;
    }
    void playing() override {
        cout << "Poker playing" << endl;
    }
    void end() override {
        cout << "Poker end" << endl;
    }
};


int main() {
    unique_ptr<Game> chess = make_unique<Chess>();
    chess->play();

    unique_ptr<Game> soccer = make_unique<Poker>();
    soccer->play();

    return 0;
}
  • Game 类定义了游戏的基本流程（play 方法），这是一个固定的算法骨架。
  • 子类 Chess, Poker 分别实现这些步骤，根据不同游戏的需要重定义 start, playing, 和 end 方法。
  • 新功能的引入（如在 Chess 中的 newFeature 方法和 addNewGameFeature 钩子）展示了模板方法的扩展性，允许在不改变主流程的情况下插入新的行为。

Template Method模式最关键的一点在于，通过继承实现固定算法的框架，并且允许子类实现特定的步骤，从而实现代码复用，控制子类扩展以及保证算法的稳定性。

全栈小社恐
关注
  • 52
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
r语言遗传算法的实现（应用mcga包和genalg包）
weixin_45178611的博客
08-15 5534
用r语言实现遗传算法 遗传算法是一类常见的随机化搜索方法，目前被广泛应用于组合优化，机器学习，信号处理，人工智能等领域。 这里以模型参数优化为背景学习遗传算法的r语言实现 r语言中常用的实现遗传算法的包有mcga包、genalg包、rgenoud包。 其中mcga、genalg包比较简单，上手较快。rgenoud包将遗传算法和衍生的牛顿算法结合起来，可以求解复杂函数的优化问题。 这里主要学习mcga包，genalg包的用法 mcga包使用字节表示变量，而不是实值，并且基于这些用字节表示的染色体进行经典的交叉
C语言函数大全（包含大部分的函数，每个函数包括函数名，功能，用法，举例。）
南风fahaxiki
03-09 9890
因为文章内容太长，这里只发了一部分，加入编程秃头俱乐部免费获取。还有更多学习资料等你来拿。 函数名: abort 功能: 异常终止一个进程 用法: voidabort(void); 程序例: #include <stdio.h> #include <stdlib.h> int main(void) { printf("Calling abort()\n"); abort(); return 0;/* This is never reached */ ...
MCGA: Make Code GREAT Again系列之设计模式关卡三：Observer观察者模式
qqpz8848的博客
05-02 1931
在软件构建的过程中，我们需要为某些对象建立一种通知依赖关系，一个对象的状态发生改变，所有依赖对象都能够得到通知。为了解决这个问题，我们可以使用一个抽象接口，将依赖关系松耦合，从而避免对实现细节的困扰，但是如果没有基类怎么办？例如，Qt和Java的Swing都是典型的基于事件的UI框架。一直都是一个进度条的实现，它可能是百分比/图形化/非图形化等等各种显示，它会导致我们产生实现细节的困扰。定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都得到通知并且自动更新。
MCGA: Make Code GREAT Again系列之设计模式关卡二：Strategy策略模式
qqpz8848的博客
05-01 10
Strategy策略模式主要适用于分支较多且容易变换的场景，我们希望代码扩展开放，并且对于更改封闭。
MCGA: Make Code GREAT Again系列之设计模式关卡五：Bridge桥模式
qqpz8848的博客
05-08 527
第五章 Bridge 桥模式。由于某些类型的固有实现逻辑，使得他们具有两个乃至多个维度的变化。如何应对这种多维度的变化，但是又不增加额外的复杂度，需要进行设计。 桥模式可以将抽象化与实现化解耦，使得二者独立地变化，使得代码更加灵活
MCGA: Make Code GREAT Again系列之设计模式关卡四：Decorator装饰器模式
qqpz8848的博客
05-02 1326
装饰器模式是一种面向对象设计模式，通过对象组合来为现有类或对象添加新功能。它克服了通过继承扩展功能的局限性，避免了继承层次膨胀和代码冗余的问题。该模式的核心思想是通过组合实现的方式，为对象添加行为而不修改其结构。它由基类接口、具体类、装饰器类和具体装饰器组成，其中装饰器类持有对象指针，通过组合为对象添加功能。装饰器模式的应用广泛，包括增强现有功能、日志记录、缓存、权限管理等。它提供了灵活的扩展能力，使得软件开发更具弹性。组合优于继承，装饰器模式通过运行时动态扩展对象功能，解决了多方向功能扩展问题。
c语言课程设计作业五子棋,c语言课程设计案例-五子棋.ppt
weixin_42502040的博客
05-16 426
《c语言课程设计案例-五子棋.ppt》由会员分享，可在线阅读，更多相关《c语言课程设计案例-五子棋.ppt(25页珍藏版)》请在人人文库网上搜索。1、C语言综合编程训练,C程序组成,开发方法: 自上向下，逐步细化，模块化设计，结构化编码,一般来说,开发一个软件要经过以下步骤:,确定软件的功能,定义核心数据结构,对整个软件进行功能模块划分,编写程序实现各功能模块,对源程序进行编译和调试,形成软件产品...
C语言函数大全--d开头的函数
Huazie
03-28 2253
C语言函数大全-d开头的函数
C语言怎样初始化图形模式？
PAP
06-10 326
C语言怎样初始化图形模式？
trabajo-mcga:REACT类
04-15
在开发模式下运行应用程序。 打开在浏览器中查看它。 如果您进行编辑，则页面将重新加载。 您还将在控制台中看到任何棉绒错误。 npm test 在交互式监视模式下启动测试运行器。 有关更多信息，请参见关于的部分。 ...
卡尔库拉多拉：MCGA
02-21
Calculadora 高尔夫协会
C语言图形设计参考资料
06-08
适合想将界面做得稍微漂亮些的新手，ppt...enum graphics_driver{DETECT,CGA,MCGA,EGA,EGA64,………,VGA,PC3270}; DETECT——自动检测所用显示适配器的类型，将相应的驱动程序装入，并将其最高显示模式作为当前显示模式
视频显示卡一个直接写屏的例子
10-22
在文本DMA将从段B000H开始的4KB内存当显存，许多既具有文本模式又具有图形模式的适配器（CGA、EGA、MCGA、VGA）都使用B800H开始的16KB内存当作显存。在显存里，每一个字符显示位置都分配了2个字节。第一个字节（偶地
用于GSM信道分配中的一种改进组合遗传算法* (2003年)
05-14
在组合遗传算法（CGA）的基础上提出一种改进方法——改进组合遗传算法（MCGA）。这种算法不但对较容易的基准信道分配问题获得了较好的结果，而且解决了对分配难度较大的信道分配问题，同时具有收敛率高、计算时间短...
C++设计模式——Bridge桥接模式
CoderZZ_2024的博客
06-14 911
设计模式入门
设计模式-代理模式
最新发布
明戈戈的博客
06-14 740
在对已有的方法进行使用的时候需要对原有方法进行改进或者修改，这时候有两种改进选择：修改原有方法来适应现在的使用方式，或者使用一个“第三者”方法来调用原有的方法，并且对方法产生的结果进行一定的控制。上面的代码表面上看很复杂，但它的作用其实很简单，就是告诉 DynamicProxy 类用一个指定的类加载器来动态创建一个对象，该对象要实现指定的接口(本例为Soucable)，并用提供的InvocationHandler来代替传统的方法主体。代理模式中的代理者就好比中介机构，它提供了对被代理对象的一切事物。
23种设计模式之代理模式
好我谢特的博客
06-09 547
一文看懂代理模式
设计模式-建造者模式
Sun的个人博客
06-10 535
*** Description: 抽象的建造房屋的类*/// 打地基// 砌墙// 封顶// 造房子roofed();/*** Description: 产品*/
请写出graphics.h中initgraph函数1
06-10
`initgraph()`函数是C语言图形库`graphics.h`中的一个函数，用于初始化图形库。该函数具有多个重载形式，以下是其中一种形式的函数原型和参数说明： ```c void initgraph(int *graphdriver, int *graphmode, char ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

全栈小社恐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值