C++ 设计模式——策略模式

策略模式

    • 策略模式
      • 主要组成部分
      • 例一：逐步重构并引入策略模式
        • 第一步：初始实现
        • 第二步：提取共性并实现策略接口
        • 第三步：实现具体策略类
        • 第四步：实现上下文类
        • 策略模式 UML 图
          • 策略模式的 UML 图解析
      • 例二：逐步重构并引入策略模式
        • 第一步：初始实现
        • 第二步：提取共性并实现策略接口
        • 第三步：实现具体策略类
        • 第四步：实现上下文类：
        • 第五步：更新主函数
      • 策略模式 UML 图
        • 策略模式的 UML 图解析
      • 策略模式优缺点
      • 策略模式适用场景
      • 例一的完整代码
      • 例二的完整代码

策略模式

策略模式是一种行为设计模式，它定义了一系列算法，将每一个算法封装起来，并使它们可以互换。策略模式让算法的变化独立于使用算法的客户。

引入"策略“设计模式的定义：定义一些列算法类（策略类），将每个算法封装起来，让他们可以互相替换。换句话说，策略模式通常把一系列算法封装到一系列具体策略类中作为抽象策略类的字类，然后根据实际需要适用这些字类。

主要组成部分

  • 策略接口 (Strategy)：定义一个统一的接口，声明所有支持的算法（策略）的方法。客户端通过这个接口调用具体策略。

  • 具体策略类 (Concrete Strategy)：实现策略接口，定义具体的算法或行为。每个具体策略类实现不同的算法。

  • 上下文类 (Context)：持有对策略接口的引用，负责调用具体策略的方法。上下文类可以在运行时动态地切换策略。

例一：逐步重构并引入策略模式

假设我们需要实现不同的排序算法（如冒泡排序和快速排序）。最初的实现可能是重复的代码。逐步重构的过程如下：

第一步：初始实现

为每种排序算法编写独立的处理逻辑：

#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& arr) {
    for (size_t i = 0; i < arr.size() - 1; ++i) {
        for (size_t j = 0; j < arr.size() - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
            }
        }
    }
}

void quickSort(std::vector<int>& arr, int low, int high) {
    if (low < high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; ++j) {
            if (arr[j] < pivot) {
                ++i;
                std::swap(arr[i], arr[j]);
            }
        }
        std::swap(arr[i + 1], arr[high]);
        quickSort(arr, low, i);
        quickSort(arr, i + 2, high);
    }
}

int main() {
    std::vector<int> data = {5, 3, 8, 6, 2};

    bubbleSort(data);
    // 或者使用 quickSort(data, 0, data.size() - 1);

    return 0;
}
第二步：提取共性并实现策略接口

识别出排序的共性步骤，并创建一个策略接口 SortStrategy，定义排序方法：

class SortStrategy {
public:
    virtual void sort(std::vector<int>& arr) = 0; // 策略接口
};
第三步：实现具体策略类

为每种排序算法实现具体策略类，重写排序方法：

class BubbleSort : public SortStrategy {
public:
    void sort(std::vector<int>& arr) override {
        for (size_t i = 0; i < arr.size() - 1; ++i) {
            for (size_t j = 0; j < arr.size() - i - 1; ++j) {
                if (arr[j] > arr[j + 1]) {
                    std::swap(arr[j], arr[j + 1]);
                }
            }
        }
    }
};

class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& arr) override {
        quickSort(arr, 0, arr.size() - 1);
    }

private:
    void quickSort(std::vector<int>& arr, int low, int high) {
        if (low < high) {
            int pivot = arr[high];
            int i = low - 1;
            for (int j = low; j < high; ++j) {
                if (arr[j] < pivot) {
                    ++i;
                    std::swap(arr[i], arr[j]);
                }
            }
            std::swap(arr[i + 1], arr[high]);
            quickSort(arr, low, i);
            quickSort(arr, i + 2, high);
        }
    }
};
第四步：实现上下文类

创建一个上下文类 Sorter，用于使用策略：

class Sorter {
private:
    SortStrategy* strategy;

public:
    Sorter(SortStrategy* strategy) : strategy(strategy) {}

    void setStrategy(SortStrategy* strategy) {
        this->strategy = strategy;
    }

    void sort(std::vector<int>& arr) {
        strategy->sort(arr);
    }
};
策略模式 UML 图

策略模式 UML 图1

策略模式的 UML 图解析

  • 上下文类 (Context)：

    • Sorter 类：它是上下文类，负责使用策略并持有策略的引用。Sorter 类通过 setStrategy 方法设置具体的排序策略，并通过 sort 方法调用该策略进行排序。

  • 抽象策略类 (Strategy)：

    • SortStrategy 类：这是策略接口，定义了一个公共方法 sort，该方法由具体策略类实现。它确保所有具体策略类都有一致的接口。

  • 具体策略类 (Concrete Strategy)：

    • BubbleSort 类：实现了 SortStrategy 接口，提供了冒泡排序的具体实现。
    • QuickSort 类：实现了 SortStrategy 接口，提供了快速排序的具体实现。

例二：逐步重构并引入策略模式

第一步：初始实现

首先，从一个简单的实现开始，其中战斗者类直接实现道具使用逻辑。

#include <iostream>
using namespace std;

class Fighter {
public:
    Fighter(int life) : m_life(life) {}
    
    void UseBXD() { // 使用补血丹
        m_life += 200;
        cout << "使用补血丹，生命值增加200。" << endl;
    }

    void UseDHD() { // 使用大还丹
        m_life += 300;
        cout << "使用大还丹，生命值增加300。" << endl;
    }

    void UseSHD() { // 使用守护丹
        m_life += 500;
        cout << "使用守护丹，生命值增加500。" << endl;
    }

    int GetLife() {
        return m_life;
    }

private:
    int m_life;
};

int main() {
    Fighter warrior(1000);
    cout << "初始生命值：" << warrior.GetLife() << endl;

    warrior.UseDHD();
    cout << "当前生命值：" << warrior.GetLife() << endl;

    warrior.UseBXD();
    cout << "当前生命值：" << warrior.GetLife() << endl;

    warrior.UseSHD();
    cout << "当前生命值：" << warrior.GetLife() << endl;

    return 0;
}
第二步：提取共性并实现策略接口

在该实现中，Fighter 类包含所有道具使用的逻辑。可以提取出道具使用的共性，定义一个道具策略接口。

class ItemStrategy {
public:
    virtual void UseItem(Fighter* fighter) = 0;
    virtual ~ItemStrategy() {}
};
第三步：实现具体策略类

为每种道具创建具体的策略类，实现 ItemStrategy 接口。

  • 补血丹策略类：
class ItemStrategy_BXD : public ItemStrategy {
public:
    void UseItem(Fighter* mainobj) override {
        mainobj->SetLife(mainobj->GetLife() + 200); // 补充200点生命值
    }
};
  • 大还丹策略类：
class ItemStrategy_DHD : public ItemStrategy {
public:
    void UseItem(Fighter* mainobj) override {
        mainobj->SetLife(mainobj->GetLife() + 300); // 补充300点生命值
    }
};
  • 守护丹策略类：
class ItemStrategy_SHD : public ItemStrategy {
public:
    void UseItem(Fighter* mainobj) override {
        mainobj->SetLife(mainobj->GetLife() + 500); // 补充500点生命值
    }
};
第四步：实现上下文类：

在 Fighter 类中添加设置道具策略的方法，并移除具体的道具使用逻辑，并定义战斗者的子类（可以不需要字类）。

class Fighter {
public:
    Fighter(int life) : m_life(life), itemStrategy(nullptr) {}

    void SetItemStrategy(ItemStrategy* strategy) {
        itemStrategy = strategy;
    }

    void UseItem() {
        if (itemStrategy) {
            itemStrategy->UseItem(this);
        }
    }

    int GetLife() {
        return m_life;
    }

    void SetLife(int life) {
        m_life = life;
    }

private:
    int m_life;
    ItemStrategy* itemStrategy;
};
class F_Warrior : public Fighter {
public:
    F_Warrior(int life, int magic, int attack) 
        : Fighter(life, magic, attack) {}
    // 其他战士特有的方法
};

class F_Mage : public Fighter {
public:
    F_Mage(int life, int magic, int attack) 
        : Fighter(life, magic, attack) {}
    // 其他法师特有的方法
};
第五步：更新主函数

更新主函数以使用新的策略模式结构。

int main() {
    Fighter warrior(1000);
    cout << "初始生命值：" << warrior.GetLife() << endl;

    ItemStrategy* strategy1 = new ItemStrategy_DHD();
    warrior.SetItemStrategy(strategy1);
    warrior.UseItem();
    cout << "当前生命值：" << warrior.GetLife() << endl;

    ItemStrategy* strategy2 = new ItemStrategy_BXD();
    warrior.SetItemStrategy(strategy2);
    warrior.UseItem();
    cout << "当前生命值：" << warrior.GetLife() << endl;

    ItemStrategy* strategy3 = new ItemStrategy_SHD();
    warrior.SetItemStrategy(strategy3);
    warrior.UseItem();
    cout << "当前生命值：" << warrior.GetLife() << endl;

    delete strategy1;
    delete strategy2;
    delete strategy3;

    return 0;
}

策略模式 UML 图

策略模式 UML 图2

策略模式的 UML 图解析
  • Context(环境类)：也叫上下文类，是使用算法的角色，该类中维持着一个对抽象策略类的指针或引用。这里指Fighter类。
  • Stategy(抽象策略类)：定义所支持的算法的公共接口，是所有策略类的父类。这里指 ItemStrategy 类。
  • ConcreteStrategy(具体策略类)：抽象策略类的子类，实现抽象策略类中声明的接口。这里指ItemStrategy_BXD、ItemStrategy_DHD、ItemStrategy_SHD类。

策略模式优缺点

优点：

  • 灵活性：可以在运行时选择不同的策略，增加了程序的灵活性和可扩展性。

  • 开放-关闭原则：新的策略可以通过实现策略接口而无需修改现有代码，符合开放-关闭原则。

  • 清晰的职责分离：将不同的算法封装在不同的类中，使得代码更加清晰，易于维护。

  • 减少条件语句：避免了使用大量的条件语句（如 if-else 或 switch），使代码结构更加简洁。

  • 易于测试：每个策略类可以独立测试，便于单元测试和调试。

缺点：

  • 类的数量增加：每种策略都需要一个新的类，可能导致类的数量增加，增加了系统的复杂性。

  • 客户端必须了解所有策略：客户端需要了解所有可用的策略，以便选择合适的策略，这可能增加了使用的复杂性。

  • 性能开销：在某些情况下，频繁地创建和销毁策略对象可能导致性能开销。

  • 不适合简单的算法：对于简单的算法，使用策略模式可能显得过于复杂，增加了不必要的抽象。

策略模式适用场景

  • 多种算法：当有多个算法可以选择时，策略模式可以将它们封装起来，方便切换。
  • 避免条件语句：当使用大量条件语句来选择算法时，可以使用策略模式来简化代码结构。
  • 动态选择算法：当需要在运行时选择算法时，策略模式提供了灵活性。
  • 算法复用：当多个类需要使用同一算法时，可以将算法封装成策略类，促进代码复用。

例一的完整代码

以下是完整的实现代码：

#include <iostream>
#include <vector>

// 策略接口
class SortStrategy
{
public:
    virtual void sort(std::vector<int>& arr) = 0; // 策略接口
};

// 具体策略：冒泡排序
class BubbleSort : public SortStrategy {
public:
    void sort(std::vector<int>& arr) override {
        for (size_t i = 0; i < arr.size() - 1; ++i) {
            for (size_t j = 0; j < arr.size() - i - 1; ++j) {
                if (arr[j] > arr[j + 1]) {
                    std::swap(arr[j], arr[j + 1]);
                }
            }
        }
    }
};

// 具体策略：快速排序
class QuickSort : public SortStrategy {
public:
    void sort(std::vector<int>& arr) override {
        quickSort(arr, 0, arr.size() - 1);
    }

private:
    void quickSort(std::vector<int>& arr, int low, int high) {
        if (low < high) {
            int pivot = arr[high];
            int i = low - 1;
            for (int j = low; j < high; ++j) {
                if (arr[j] < pivot) {
                    ++i;
                    std::swap(arr[i], arr[j]);
                }
            }
            std::swap(arr[i + 1], arr[high]);
            quickSort(arr, low, i);
            quickSort(arr, i + 2, high);
        }
    }
};

// 上下文类
class Sorter {
private:
    SortStrategy* strategy;

public:
    Sorter(SortStrategy* strategy) : strategy(strategy) {}

    void setStrategy(SortStrategy* strategy) {
        this->strategy = strategy;
    }

    void sort(std::vector<int>& arr) {
        strategy->sort(arr);
    }
};

// 示例用法
int main() {
    std::vector<int> data = {5, 3, 8, 6, 2};

    Sorter sorter(new BubbleSort());
    sorter.sort(data); // 使用冒泡排序

    sorter.setStrategy(new QuickSort());
    sorter.sort(data); // 使用快速排序

    return 0;
}

例二的完整代码

#include <iostream>
using namespace std;

class Fighter; // 类前向声明

//道具策略类的父类
class ItemStrategy
{
public:
    virtual void UseItem(Fighter* mainobj) = 0;
    virtual ~ItemStrategy() {}
};

//战斗者父类
class Fighter
{
public:
    Fighter(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
    virtual ~Fighter() {}

public:
    void SetItemStrategy(ItemStrategy* strategy) //设置道具使用的策略
    {
        itemstrategy = strategy;
    }
    void UseItem() //使用道具（吃药）
    {
        itemstrategy->UseItem(this);
    }
    int  GetLife() //获取人物生命值
    {
        return m_life;
    }
    void SetLife(int life) //设置人物生命值
    {
        m_life = life;
    }

private:
    ItemStrategy* itemstrategy = nullptr; //C++11中支持这样初始化

protected:
    int m_life;
    int m_magic;
    int m_attack;
};

//“战士”类，父类为Fighter
class F_Warrior :public Fighter
{
public:
    F_Warrior(int life, int magic, int attack) :Fighter(life, magic, attack) {}
};

//“法师”类，父类为Fighter
class F_Mage :public Fighter
{
public:
    F_Mage(int life, int magic, int attack) :Fighter(life, magic, attack) {}
};


//补血丹策略类
class ItemStrategy_BXD : public ItemStrategy
{
public:
    virtual void UseItem(Fighter* mainobj)
    {
        mainobj->SetLife(mainobj->GetLife() + 200); //补充200点生命值
        cout << "使用补血丹，生命值增加200。" << endl;
    }
};

//大还丹策略类
class ItemStrategy_DHD : public ItemStrategy
{
public:
    virtual void UseItem(Fighter* mainobj)
    {
        mainobj->SetLife(mainobj->GetLife() + 300); //补充300点生命值
        cout << "使用大还丹，生命值增加300。" << endl;
    }
};

//守护丹策略类
class ItemStrategy_SHD : public ItemStrategy
{
public:
    virtual void UseItem(Fighter* mainobj)
    {
        mainobj->SetLife(mainobj->GetLife() + 500); //补充500点生命值
        cout << "使用守护丹，生命值增加500。" << endl;
    }
};

int main()
{
    // 创建战斗者对象
    Fighter* prole_war = new Fighter(1000, 0, 200);

    // 打印初始生命值
    cout << "初始生命值：" << prole_war->GetLife() << endl;

    // 使用大还丹
    ItemStrategy* strategy1 = new ItemStrategy_DHD();
    prole_war->SetItemStrategy(strategy1);
    prole_war->UseItem();
    cout << "当前生命值：" << prole_war->GetLife() << endl;

    // 使用补血丹
    ItemStrategy* strategy2 = new ItemStrategy_BXD();
    prole_war->SetItemStrategy(strategy2);
    prole_war->UseItem();
    cout << "当前生命值：" << prole_war->GetLife() << endl;

    // 使用守护丹
    ItemStrategy* strategy3 = new ItemStrategy_SHD();
    prole_war->SetItemStrategy(strategy3);
    prole_war->UseItem();
    cout << "当前生命值：" << prole_war->GetLife() << endl;

    // 释放资源
    delete strategy1;
    delete strategy2;
    delete strategy3;
    delete prole_war;
    
    F_Mage mage(800, 300, 100);
    cout << "法师初始生命值：" << mage.GetLife() << endl;

    // 可以为法师设置道具策略并使用
    // ...

    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/871777.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Java Web —— 第七天（Mybatis案例 员工管理2）

Java Web —— 第七天（Mybatis案例 员工管理2）

新增员工 EmpController类 PostMappingpublic Result save(RequestBody Emp emp){log.info("新增员工操作,emp:{}",emp);empService.save(emp);return Result.success();} EmpServiceImpl实现类 //新增员工Overridepublic void save(Emp emp) {//补充基础属性 创…
阅读更多...
台球助教在线预约小程序源码开发：打造便捷高效的台球学习新体验

台球助教在线预约小程序源码开发：打造便捷高效的台球学习新体验

在当今快节奏的生活中&#xff0c;台球作为一项集休闲、竞技与社交于一体的运动&#xff0c;受到了越来越多人的喜爱。然而&#xff0c;对于初学者而言&#xff0c;想要快速提升技能&#xff0c;往往需要专业的指导和陪练。传统的台球教练预约方式往往存在信息不对称、预约流程…
阅读更多...
【Qt笔记】Qt界面显示时间

【Qt笔记】Qt界面显示时间

目录 一、前言 二、基本概念 三、代码实现 1. 获取本地时间&#xff0c;并将其转换成自己想要的格式 2.创建一个QLabel控件用于显示时间字符串 3.创建QTimer定时器更新时间 四、优化 1. 格式优化 1.1 初始化 1.2 获取星期 1.3 更改格式 1.4 定时器超时函数 1.5 …
阅读更多...
多商户多套部署需修改注意事项

多商户多套部署需修改注意事项

同一台服务器上部署多个多商户项目&#xff0c;需要修改和调整的地方等。 一、修改代码中的端口号&#xff0c;需要两个项目不能使用同一个端口号&#xff0c;例如&#xff1a;A项目用&#xff1a;8324&#xff0c;B项目用&#xff1a;8325&#xff1b; 二、修改反向代理&…
阅读更多...
LCP 633 平方数之和 [leetcode - 8]

LCP 633 平方数之和 [leetcode - 8]

最近是在研究双指针啊&#xff0c;leetcode刷的题都是这方面的。都记录在最近的文章里&#xff0c;大家有兴趣可以去我主页看看 LCP633 平方数之和 给定一个非负整数 c &#xff0c;你要判断是否存在两个整数 a 和 b&#xff0c;使得 a2 b2 c 。 示例 1&#xff1a; 输入&…
阅读更多...
Modbus 数据帧解析

Modbus 数据帧解析

Modbus 是一种通信协议&#xff0c;广泛应用于工业自动化系统中&#xff0c;用于连接电子设备。它是一种基于主从结构的通信协议&#xff0c;其中主设备可以与多个从设备通信。数据通过一系列的帧进行传输&#xff0c;每一帧包含多个字段&#xff0c;每个字段都有特定的功能。 …
阅读更多...
HTML 列表和容器元素——WEB开发系列10

HTML 列表和容器元素——WEB开发系列10

HTML 提供了多种方式来组织和展示内容&#xff0c;其中包括无序列表、有序列表、分区元素 ​​<div>​​ 和内联元素 ​​<span>​​、以及如何使用 ​​<div>​​​ 进行布局和表格布局。 一、HTML 列表 1. 无序列表 (​​<ul>​​) 无序列表用于展…
阅读更多...
【Win开发环境搭建】Redis与可视化工具详细安装与配置过程

【Win开发环境搭建】Redis与可视化工具详细安装与配置过程

&#x1f3af;导读&#xff1a;本文档提供了Redis的简介、安装指南、配置教程及常见操作方法。包括了安装包的选择与配置环境变量的过程&#xff0c;详细说明了如何通过修改配置文件来设置密码和端口等内容。同时&#xff0c;文档还介绍了如何使用命令行工具连接Redis&#xff…
阅读更多...
科研软件 | Diamond 4.6 安装教程

科研软件 | Diamond 4.6 安装教程

软件介绍 Diamond一个化学专业软件。它是一款在原子水平实现晶体结构可视化的软件&#xff0c;包括分子和聚合物扩展、多面体、搜索结构数据、自动和批量创建结构图片等功能&#xff0c;支持晶体结构着色和渲染以及批注。 软件下载 https://pan.quark.cn/s/37214b5bec7c 软…
阅读更多...
05、Redis实战：优惠券秒杀、优化异步下单

05、Redis实战：优惠券秒杀、优化异步下单

6、秒杀优化 6.1 秒杀优化-异步秒杀思路 我们先来回顾一下下单流程当用户发起请求&#xff0c;此时会先请求Nginx&#xff0c;Nginx反向代理到Tomcat&#xff0c;而Tomcat中的程序&#xff0c;会进行串行操作&#xff0c;分为如下几个步骤 查询优惠券判断秒杀库存是否足够查询…
阅读更多...
音视频相关知识

音视频相关知识

H.264编码格式 音频 PCM就是要把声音从模拟信号转换成数字信号的一种技术&#xff0c;他的原理简单地说就是利用一个固定的频率对模拟信号进行采样。 pcm是无损音频音频文件格式 每秒15帧 一秒钟300kb 单位&#xff1a;像素
阅读更多...
故障频发，给我一个完美的解释...

故障频发，给我一个完美的解释...

1.盘点事故 8月19日&#xff0c;网易云音乐「崩了」&#xff0c;网页端报错&#xff0c;App 无法使用&#xff0c;什么原因&#xff1f;你那受影响了吗&#xff1f; 一次更新&#xff0c;一串代码&#xff0c;全球宕机。7月19日下午发生了全球范围内的Windows大面积蓝屏事件&a…
阅读更多...
Django | 从中间件的角度来认识Django发送邮件功能

Django | 从中间件的角度来认识Django发送邮件功能

文章目录 概要中间件中间件 ---> 钩子实现中间件demo 邮件发送过程Django如何做邮件服务配置流程 中间件结合邮件服务实现告警 概要 摘要 业务告警 邮件验证 密码找回 邮件告警 中间件 中间件 —> ‘钩子’ 例如 访问路由 的次数【请求】 中间件类须实现下列五个方法…
阅读更多...
C++，std::queue 详解

C++，std::queue 详解

文章目录 1. 概述2. 包含头文件3. 基本操作3.1 构造函数3.2 赋值操作3.3 成员函数 4. 迭代器5. 示例6. 注意事项参考 1. 概述 std::queue 是 C 标准模板库&#xff08;STL&#xff09;中的一个容器适配器&#xff0c;它提供了一种先进先出&#xff08;FIFO&#xff09;的数据结…
阅读更多...
[数据集][目标检测]木材缺陷检测数据集VOC+YOLO格式2383张10类别

[数据集][目标检测]木材缺陷检测数据集VOC+YOLO格式2383张10类别

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;2383 标注数量(xml文件个数)&#xff1a;2383 标注数量(txt文件个数)&#xff1a;2383 标注…
阅读更多...
网络安全入门教程（非常详细）从零基础入门到精通_网路安全 教程

网络安全入门教程（非常详细）从零基础入门到精通_网路安全 教程

前言 1.入行网络安全这是一条坚持的道路&#xff0c;三分钟的热情可以放弃往下看了。2.多练多想&#xff0c;不要离开了教程什么都不会了&#xff0c;最好看完教程自己独立完成技术方面的开发。3.有时多百度&#xff0c;我们往往都遇不到好心的大神&#xff0c;谁会无聊天天给…
阅读更多...
线性数据结构的基本概念（数组，链表，栈，队列）

线性数据结构的基本概念（数组，链表，栈，队列）

数组 数组由相同类型的元素组成&#xff0c;使用一块连续的内存来存储。 数组的特点是&#xff1a; 1.利用索引进行访问 2.容量固定 3.使用一块连续的内存来存储 各种操作的时间复杂度&#xff1a; 查找/修改&#xff1a;O&#xff08;1&#xff09;//访问特定位置的元素 插入…
阅读更多...
[鹏城杯 2022]简单的php

[鹏城杯 2022]简单的php

题目源代码 <?phpshow_source(__FILE__); $code $_GET[code]; if(strlen($code) > 80 or preg_match(/[A-Za-z0-9]|\|"||\ |,|\.|-|\||\/|\\|<|>|\$|\?|\^|&|\|/is,$code)){die( Hello); }else if(; preg_replace(/[^\s\(\)]?\((?R)?\)/, , $code…
阅读更多...
Qt实现tcp协议

Qt实现tcp协议

void Widget::readyRead_slot() {//读取服务器发来的数据QByteArray msg socket->readAll();QString str QString::fromLocal8Bit(msg);QStringList list str.split(:);if(list.at(0) userName){QString str2;for (int i 1; i < list.count(); i) {str2 list.at(i);…
阅读更多...
使用DOM破坏启动xss

使用DOM破坏启动xss

目录 实验环境&#xff1a; 分析&#xff1a; 找破坏点&#xff1a; 查看源码找函数&#xff1a; 找到了三个方法&#xff0c;loadComments、escapeHTM 、displayComments loadComments escapeHTM displayComments&#xff1a; GOGOGO 实验环境&#xff1a; Lab: Exp…
阅读更多...
最新文章

Copyright @ 2022~2023