备忘录、迭代器和解释器模式（行为型设计模式）的 C++ 代码示例模板

最新推荐文章于 2024-05-04 18:38:50 发布
最新推荐文章于 2024-05-04 18:38:50 发布
阅读量1k 收藏 23
点赞数 17
分类专栏： 设计模式 文章标签： 备忘录模式 迭代器模式 解释器模式 设计模式 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62083249/article/details/135163140
版权

文章目录

前言

备忘录、迭代器和解释器模式（行为型设计模式）的 C++ 代码示例模板。

代码仓库

备忘录模式（Memento）

结构

  • 备忘录类（保存 发起者对象 的状态）
  • 发起者类（需要保存和恢复状态 的对象）
  • 管理者类（管理备忘录对象）
  • 备忘录类 封装 状态属性，保存状态方法，获取状态方法
  • 发起者类 封装 状态属性，设置状态方法，创建备忘录（保存状态）方法（将状态交给备忘录保存），恢复备忘录（恢复状态）方法（从备忘录获取/恢复状态）
  • 管理者类 封装 添加备忘录方法，获取备忘录方法
  • 备忘录过程：发起者 调用 创建备忘录（保存状态）方法 -> 管理者 调用 添加备忘录方法；管理者 调用 获取备忘录方法 -> 发起者 调用 恢复备忘录（恢复状态）方法
  • 基于嵌套类的实现中，备忘录类 是 发起者类 的内部类，发起者类 管理 备忘录类 的创建和恢复，通常不需要管理者类

类型：

  • 基于非嵌套类/接口的实现：支持和不支持嵌套类的编程语言（如 PHP） 可以实现
  • 基于嵌套类的实现：只能在 支持嵌套类的编程语言（如 C++、 C# 和 Java） 实现

代码（基于非嵌套类/接口的实现）

#include <string>
#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

// 备忘录类（保存 发起者对象 的状态）
// 备忘录类 封装 状态属性，保存状态方法，获取状态方法
class Memento
{
public:
    Memento(string state) : state(state) {} // 保存状态

    // 设置状态

    // 获取状态
    string get_state()
    {
        return this->state;
    }

private:
    string state; // 状态
};

// 发起者类（需要保存和恢复状态 的对象）
// 发起者类 封装 状态属性，设置状态方法，创建备忘录（保存状态）方法（将状态交给备忘录保存），恢复备忘录（恢复状态）方法（从备忘录获取/恢复状态）
class Initiator
{
public:
    // 设置状态
    void set_state(string state)
    {
        this->state = state;
        cout << "Current state: " << this->state << endl;
    }

    // 获取状态

    // 创建备忘录（保存状态）
    Memento create_memento()
    {
        return Memento(this->state); // 将状态交给备忘录保存
    }

    // 恢复备忘录（恢复状态）
    void restore_memento(Memento memento)
    {
        this->state = memento.get_state(); // 从备忘录获取/恢复状态
        cout << "State restores to: " << this->state << endl;
    }

private:
    string state; // 状态
};

// 管理者类（管理备忘录对象）
// 管理者类 封装 添加备忘录方法，获取备忘录方法
class Administrator
{
public:
    // 添加备忘录
    void add_memento(Memento memento)
    {
        this->memento_vec.push_back(memento);
    }

    // 获取备忘录
    const Memento get_memento(int index)
    {
        return this->memento_vec.at(index);
    }

private:
    vector<Memento> memento_vec;
};

// 客户端
int main()
{
    // 发起者对象
    Initiator initiator;
    // 管理者对象
    Administrator administrator;

    initiator.set_state("State 1"); // 设置状态
    // 备忘录对象
    Memento memento_1 = initiator.create_memento(); // 1. 创建备忘录（保存状态）
    administrator.add_memento(memento_1);           // 2. 添加备忘录

    initiator.set_state("State 2");                   // 设置状态
    Memento memento_2 = administrator.get_memento(0); // 3. 获取备忘录
    initiator.restore_memento(memento_2);             // 4. 恢复备忘录（恢复状态）
    // 备忘录过程：
    // 发起者 调用 创建备忘录（保存状态）方法 -> 管理者 调用 添加备忘录方法
    // 管理者 调用 获取备忘录方法 -> 发起者 调用 恢复备忘录（恢复状态）方法

    return 0;
}
/*
输出：
Current state: State 1
Current state: State 2
State restores to: State 1
*/

代码（基于嵌套类的实现）

#include <string>
#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

// 发起者类（需要保存和恢复状态 的对象）
// 发起者类 封装 状态属性，设置状态方法，创建备忘录（保存状态）方法（将状态交给备忘录保存），恢复备忘录（恢复状态）方法（从备忘录获取/恢复状态）
class Initiator
{
public:
    // 备忘录类（保存 发起者对象 的状态）
    // 备忘录类 封装 状态属性，保存状态方法，获取状态方法
    class Memento
    {
    public:
        Memento(string state) : state(state) {} // 保存状态

        // 设置状态

        // 获取状态
        string get_state()
        {
            return this->state;
        }

    private:
        string state; // 状态
    };

public:
    // 设置状态
    void set_state(string state)
    {
        this->state = state;
        cout << "Current state: " << this->state << endl;
    }

    // 获取状态

    // 创建备忘录（保存状态）
    Memento create_memento()
    {
        return Memento(this->state); // 将状态交给备忘录保存
    }

    // 恢复备忘录（恢复状态）
    void restore_memento(Memento memento)
    {
        this->state = memento.get_state(); // 从备忘录获取/恢复状态
        cout << "State restores to: " << this->state << endl;
    }

private:
    string state; // 状态
};

// 基于嵌套类的实现中，备忘录类 是 发起者类 的内部类，发起者类 管理 备忘录类 的创建和恢复，通常不需要管理者类

// 客户端
int main()
{
    // 发起者对象
    Initiator initiator;

    initiator.set_state("State 1"); // 设置状态
    // 备忘录对象
    Initiator::Memento memento_1 = initiator.create_memento(); // 1. 创建备忘录（保存状态）

    initiator.set_state("State 2");       // 设置状态
    initiator.restore_memento(memento_1); // 2. 恢复备忘录（恢复状态）

    return 0;
}
/*
输出：
Current state: State 1
Current state: State 2
State restores to: State 1
*/

迭代器模式（Iterator）

结构

  • 项目类（需要迭代 的对象）
  • 抽象迭代器类
  • 具体迭代器类（帮助迭代 的对象）
  • 抽象聚合类
  • 具体聚合类（连接 项目集合 和 迭代器，获取 并 使用 项目集合 创建 迭代器）
  • 抽象迭代器类 封装 获取第一个项目方法 和 获取下一个项目方法
  • 具体迭代器类 封装 项目指针（实际上指向一个项目对象）的集合属性 和 项目集合的当前索引属性
  • 具体迭代器类 重写 获取第一个项目方法 和 获取下一个项目方法
  • 抽象聚合类 封装 创建迭代器方法
  • 具体聚合类 封装 项目指针（实际上指向一个项目对象）的集合属性 和 重写 创建迭代器方法（抽象迭代器指针类型 的 具体迭代器指针）

代码

#include <string>
#include <vector>
#include <iostream>

using std::cout;
using std::endl;
using std::string;
using std::vector;

// 项目类（需要迭代 的对象）
class Item
{
public:
    Item(string name) : name(name) {}

    // 获取名称
    string get_name()
    {
        return this->name;
    }

private:
    string name; // 名称
};

// 抽象迭代器类
class AbstractIterator
{
public:
    virtual Item *get_first() = 0; // 获取第一个项目
    virtual Item *get_next() = 0;  // 获取下一个项目
};

// 具体迭代器类（帮助迭代 的对象）
class ConcreteIterator : public AbstractIterator
{
public:
    ConcreteIterator(vector<Item *> item_vec) : item_vec(item_vec), cur_index(0) {}

    // 获取第一个项目
    Item *get_first() override
    {
        Item *item = this->item_vec[0];

        if (item != nullptr) // 有第一个项目
        {
            return item; // 返回第一个项目
        }
        else // 无第一个项目
        {
            return nullptr; // 返回空指针
        }
    }

    // 获取下一个项目
    Item *get_next() override
    {
        if ((this->cur_index < (this->item_vec.size() - 1)) == true)
        // 索引 = 大小 - 1
        // 如果 项目的当前索引 小于 项目集合的大小 - 1，返回 true，有下一个项目
        // 如果 项目的当前索引 等于或大于 项目集合的大小 - 1，返回 false，无下一个项目
        {
            ++this->cur_index;
            Item *item = this->item_vec[this->cur_index];

            return item;
        }
        else
        {
            return nullptr;
        }
    }

private:
    vector<Item *> item_vec; // 项目指针（实际上指向一个项目对象）的集合
    size_t cur_index;        // 项目集合的当前索引
};

// 抽象聚合类
class AbstractAggregate
{
public:
    virtual AbstractIterator *create_iterator() = 0; // 创建迭代器
};

// 具体聚合类（连接 项目集合 和 迭代器，获取 并 使用 项目集合 创建 迭代器）
class ConcreteAggregate : public AbstractAggregate
{
public:
    ConcreteAggregate(vector<Item *> item_vec) : item_vec(item_vec) {}

    // 创建迭代器（抽象迭代器指针类型 的 具体迭代器指针）
    AbstractIterator *create_iterator() override
    {
        return new ConcreteIterator(this->item_vec);
    }

private:
    vector<Item *> item_vec;
};

// 客户端
int main()
{
    // 项目对象的集合
    Item *item_1 = new Item("Item1");
    Item *item_2 = new Item("Item2");
    Item *item_3 = new Item("Item3");
    vector<Item *> item_vec = {item_1, item_2, item_3};

    // 具体聚合对象
    ConcreteAggregate aggregate(item_vec);

    // 抽象迭代器指针类型 的 具体迭代器指针
    AbstractIterator *iterator = aggregate.create_iterator(); // 创建迭代器

    // 使用 具体迭代器指针 遍历 项目对象的集合
    for (Item *item = iterator->get_first(); item != nullptr; item = iterator->get_next())
    {
        cout << "Item: " << item->get_name() << endl;
    }

    delete iterator;
    for (Item *item : item_vec)
    {
        delete item;
    }

    return 0;
}
/*
输出：
Item: Item1
Item: Item2
Item: Item3
*/

解释器模式（Interpreter）

结构

  • 抽象表达式类
  • 终结符表达式类 （树叶结点；用于将 变量 解释为 值）
  • 非终结符表达式类 （树枝结点；用于将 表达式 解释为 操作）
  • 上下文类（用于 设置 变量和值的映射 和 获取 变量 映射的 值）
  • 抽象表达式类 封装 解释方法
  • 终结符表达式类 封装 变量 和 重写 解释方法
  • 非终结符表达式类 封装 抽象表达式指针（实际上指向一个 终结符表达式对象 或 非终结符表达式对象） 和 重写 解释方法（形式上 调用 非终结符表达式类的 解释方法， 实际上 调用 终结符表达式类 或 非终结符表达式类的 解释方法（递归））
  • 上下文类 封装 上下文/变量和值的映射属性、设置 变量和值的映射方法 和 获取 变量 映射的 值方法
  • 创建过程：反向创建：先创建树叶，后创建树枝
  • 解释过程：正向解释：先解释树枝，后解释树叶（树状递归）

代码

#include <unordered_map>
#include <iostream>

using std::cout;
using std::endl;
using std::unordered_map;

// 抽象表达式类
class AbstractExpression
{
public:
    // 解释
    virtual int interpret(unordered_map<char, int> context_unmap) = 0;
};

// 终结符表达式类（树叶结点；用于将 变量 解释为 值）
class TerminalExpression : public AbstractExpression
{
public:
    TerminalExpression(char var) : var(var) {}

    // 解释
    int interpret(unordered_map<char, int> context_unmap) override
    {
        return context_unmap[this->var];
    }

private:
    // 变量
    char var;
};

// 非终结符表达式类（树枝结点；用于将 表达式 解释为 操作）
class NonTerminalExpression : public AbstractExpression
{
public:
    NonTerminalExpression(AbstractExpression *expr_1, AbstractExpression *expr_2) : expr_1(expr_1), expr_2(expr_2) {}

    // 解释
    int interpret(unordered_map<char, int> context_unmap) override // 形式上 调用 非终结符表达式类的 解释方法
    {
        // 这里 解释为 加法操作
        return expr_1->interpret(context_unmap) + expr_2->interpret(context_unmap); // 实际上 调用 终结符表达式类 或 非终结符表达式类的 解释方法（递归）
    }

private:
    // 抽象表达式指针（实际上指向一个 终结符表达式对象 或 非终结符表达式对象）
    AbstractExpression *expr_1;
    AbstractExpression *expr_2;
};

// 上下文类（用于 设置和获取 变量和值的映射）
class Context
{
public:
    Context() : context_unmap() {} // unordered_map<> 的默认构造方法 初始化

    // 设置 变量和值的映射
    void set_var_value(char var, int value)
    {
        this->context_unmap[var] = value;
    }

    // 获取 变量和值的映射
    unordered_map<char, int> get_var_value()
    {
        return this->context_unmap;
    }

private:
    // 上下文/变量和值的映射
    unordered_map<char, int> context_unmap;
};

// 客户端
int main()
{
    // 构建表达式：a + b
    AbstractExpression *expr_1 = new TerminalExpression('a'); // 抽象表达式指针（实际上指向一个终结符表达式对象)
    AbstractExpression *expr_2 = new TerminalExpression('b');
    AbstractExpression *expr_3 = new NonTerminalExpression(expr_1, expr_2); // 抽象表达式指针（实际上指向一个非终结符表达式对象）

    Context context; // 上下文对象
    // 设置 变量和值的映射
    context.set_var_value('a', 10);
    context.set_var_value('b', 20);

    //  获取 变量和值的映射
    unordered_map<char, int> context_unmap = context.get_var_value();

    // 解释
    int result = expr_3->interpret(context_unmap);
    cout << "Result: " << result << endl;
    // 创建过程：
    // 反向创建：先创建树叶，后创建树枝
    // 解释过程：
    // 正向解释：先解释树枝，后解释树叶（树状递归）

    delete expr_3;
    delete expr_2;
    delete expr_1;

    return 0;
}
/*
输出：
Result: 30
*/

总结

备忘录、迭代器和解释器模式（行为型设计模式）的 C++ 代码示例模板。

参考资料

作者的话

  • 感谢参考资料的作者/博主
  • 作者：夜悊
  • 版权所有，转载请注明出处，谢谢~
  • 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获
夜悊
关注
  • 17
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++常用的22种设计模式解释及示例
01-30
在软件开发中，设计模式是一种解决常见问题的模板或最佳实践，它被广泛应用于C++和其他面向对象编程语言中。以下是对C++中22种常用设计模式的详细解释及示例： 1. **单例模式（Singleton）**：确保一个类只有一个...
设计模式精解-GoF-23种设计模式解析--附C++源代码
02-18
C++源代码文件可以帮助你更好地理解如何在实际项目中应用这些模式，通过阅读和分析代码，你可以学习如何在C++中实现这些设计模式，并将它们融入到自己的编程实践中。 总而言之，设计模式是软件开发中的宝贵财富，...
【Golang项目实战】手把手教你写一个备忘录程序|附源码——建议收藏
Yaoyao2024的博客
04-25 2084
有以下5个功能查询所有备忘录新增一个备忘录删除备忘录更新备忘录退出备忘录下面详细讲解是以备忘录的标题为索引，即通过备忘录标题来查找对应备忘录内容（文章最后会附上用序号来查找的版本）这里我的想法是一条备忘录分为两个模块备忘录标题备忘录内容用map容器存储备忘录，其中备忘录标题memoHead作为key,备忘录内容作为value还有一种方案是采用map+数组+结构体存储，利用下标索引进行操作备忘录，这种方法的代码我会在最后附上。
Android安卓备忘录（笔记）大作业简单实现有源码注释详细
安卓精品项目源码
01-03 1766
/设置toolbar取代actionbar。//设置toolbar取代actionbar。mSearchView.setQueryHint("请输入搜索内容");if (openMode == 3) {//打开已存在的note。Log.d("TAG","打开");//在主界面加载成功之后 显示弹出。} //判断笔记状态。} //刷新list。} //主界面删除。哈哈界面随自己走各位别喷。
2024年Android开发之简单备忘录_android备忘录完整代码，2024年最新字节跳动面试app
最新发布
2301_82243733的博客
05-04 907
今天关于面试的分享就到这里，还是那句话，有些东西你不仅要懂，而且要能够很好地表达出来，能够让面试官认可你的理解，例如Handler机制，这个是面试必问之题。有些晦涩的点，或许它只活在面试当中，实际工作当中你压根不会用到它，但是你要知道它是什么东西。最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司2021年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。还有。
代码备忘录(CMakeLists.txt)
lzz137的博客
07-06 711
CMakeLists.txt CMAKE_BUILD_TYPE string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lower) if(cmake_build_type_lower STREQUAL "release") message(VERBOSE "begin build release") set(CMAKE_CXX_VISIBILITY_PRESET hidden) set(CMAKE_C_VISIBILITY_P
备忘录实现 源码
编程笔记
12-30 8448
首先创建保存备忘录信息的表： DbHelper.java [java] view plaincopy在CODE上查看代码片派生到我的代码片 package com.cjq.androidbwl; import android.content.Context; import android.database.sqlite.SQLiteDatabase; import
备忘录模式讲解及代码实现
qq_44703805的博客
03-30 547
1.核心 就是保存某个对象某个时刻内部状态的拷贝，这样就可以将该对象（通过拷贝的对象）恢复到原先的状态 2.结构 2.1 源发器类Originator–需要被拷贝的对象 2.2 备忘录类Memento–拷贝信息存放到此对象中 2.3 负责人类CareTaker–管理备忘录对象 3.实现方法 3.1 备忘录中的信息与源发器中的信息保持一致，备忘录中提供构造方法以源发器对象作为参数 3.2 源发器中...
C++ Design Pattern 23种设计模式(全_解释+源代码).zip
01-16
- **行为型模式**（共11种）：策略模式、模板方法模式、观察者模式、命令模式、迭代器模式、责任链模式、备忘录模式、状态模式、访问者模式、解释器模式、中介者模式。这些模式关注的是对象之间的通信和行为。 例如...
23种设计模式(C++).pdf
11-29
- 行为型模式主要关注对象之间的责任分配和通信，它们包括责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式等。这些模式分别...
23种设计模式的C++实现代码
10-08
本资源包含23种经典的设计模式的C++实现代码，这些模式通常被分为三大类：创建型、结构型和行为型。 1. **创建型设计模式**： - **单例模式**：保证一个类只有一个实例，并提供一个全局访问点。 - **工厂模式**：...
备忘录app项目源码
01-08
小型的备忘录app完整项目源码，可正常运行使用。实用性好
DIY桌面备忘录源代码
01-30
DIY桌面备忘录源代码 程序逻辑：点击录制后，程序隐藏，然后由用户使用鼠标左键在桌面上写字或者画画，通过这样的方式来设定备忘录的内容，点击鼠标右键结束录制，然后通过鼠标中间调节时间，最后点击开始定时，程序隐藏，等到设定的时间到了以后，程序自动回放刚才用户的绘图动作。
代码备忘录（经典的代码备忘录）
07-07
这是一款经典的代码备忘录软件，对于程序员来说，可以随时保存必要的代码是非常重要的，本软件有很强大的功能,方便使用。
个人备忘录
12-18
以图形用户界面的方式，实现对日常记事信息进行添加、删除、更新和查询操作。
JAVA备忘录
m0_62558103的博客
01-08 281
JAVA学习日记
Javascript——手把手教你制作专属备忘录
weixin_56286359的博客
03-17 201
基于JS的事件实现专属备忘录
1分钟就能学会Android如何展示Gif动态图
I_846815793的博客
04-26 1876
今天关于面试的分享就到这里，还是那句话，有些东西你不仅要懂，而且要能够很好地表达出来，能够让面试官认可你的理解，例如Handler机制，这个是面试必问之题。有些晦涩的点，或许它只活在面试当中，实际工作当中你压根不会用到它，但是你要知道它是什么东西。最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司2021年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。还有。
C++设计模式详解：从简单工厂到解释器模式
"C++设计模式高清文字版，涵盖了24种设计模式的详细讲解，包括简单工厂模式、策略模式、装饰模式、代理模式、工厂方法模式、原型模式、模板方法模式、外观模式、建造者模式、观察者模式、抽象工厂模式、状态模式、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值