设计模式 c++版（6）——代理模式

最新推荐文章于 2024-11-09 19:45:52 发布
最新推荐文章于 2024-11-09 19:45:52 发布
阅读量282 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 设计模式 文章标签： c 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Jecklin_online/article/details/82838903
本文详细介绍了代理模式在C++中的应用，包括代理模式的定义、通用版示例、打游戏场景下的代理模式、游戏代练帮忙打怪的代理实现、代理模式的优点以及普通代理、强制代理和有个性的代理等扩展。通过代理模式，可以实现职责清晰、高扩展性和智能化的功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

定义：

为其他对象提供一种代理以控制这个对象的访问

示例一：代理模式（通用版）

1. 类图12-3

 

2. 类图说明：

Subject 抽象主题角色：
抽象主题类可以使抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。
RealSubject 具体主题角色：
也叫被委托角色，被代理角色。它是业务逻辑的具体执行者。
Proxy 代理主题角色：
也叫委托类、代理类。它负责对真是角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真是主题角色处理完毕前后做预处理和善后处理工作。

 

3. 代码清单12-3:

////////    **********  3. 通用代理模式，代码清单12-3:***************//
#include <QDebug>
#include <QDateTime>

class Subject
{
public:
    virtual void request() = 0;
};

class RealSubject:public Subject
{
public:
    virtual void request(){qDebug() << "RealSubject request";}
};

class Proxy:public Subject
{
public:
    Proxy()
    {
        this->m_subject = new Proxy();
    }
    Proxy(Subject *subject)
    {
        this->m_subject = subject;
    }
    Proxy(QObject *object){}
    virtual void request()
    {
        this->before();
        this->m_subject->request();
        this->after();
    }
private:
    void    before(){qDebug() << "do something before";}
    void    after(){qDebug() << "do something after"; }
    
    
private:
    Subject *m_subject;
};


int main()
{
    Subject *subject = new RealSubject;
    Proxy   *proxy   = new Proxy(subject);
    proxy->request();      
                
    return 0;
}

 

示例二：打游戏

1. 类图12-1

 

2. 代码清单12-1:

////////    **********  1.打游戏 ，12-1:***************//
#include <QDebug>
#include <QDateTime>

class IGamePlayer
{
public:
    virtual void    login(QString user, QString password) = 0;
    virtual void    killBoss()                            = 0;
    virtual void    upgrade()                             = 0;
};

class GamePlayer:public IGamePlayer
{
public:
    GamePlayer(QString name)
    {
        this->m_name = name;
    }
    virtual void    login(QString user, QString password)
    {
        qDebug() << "user name:" << user << " password: " << password;
    }
    virtual void    killBoss()
    {
        qDebug() << this->m_name << "kill Boss!";
    }
    virtual void    upgrade()
    {
        qDebug() << this->m_name << "upgrade!";
    }

private:
    QString m_name;
    
};


int main()
{
    IGamePlayer *player = new GamePlayer("Tom");
    QString time = QString::fromUtf8("HH:mm:ss.zzz");
    qDebug() << QDateTime::currentDateTime().toString(time);
    player->login("Tom", "password");            
    player->killBoss();
    player->upgrade();
    qDebug() << QDateTime::currentDateTime().toString(time);        
                
    return 0;
}


示例三：游戏代练帮忙打怪

1. 类图12-2

 

2. 代码清单12-2:


////////    **********  2.游戏代练帮忙打怪 ，12-2:***************//
#include <QDebug>
#include <QDateTime>

class IGamePlayer
{
public:
    virtual void    login(QString user, QString password) = 0;
    virtual void    killBoss()                            = 0;
    virtual void    upgrade()                             = 0;
};

class GamePlayer:public IGamePlayer
{
public:
    GamePlayer(QString name)
    {
        this->m_name = name;
    }
    virtual void    login(QString user, QString password)
    {
        qDebug() << "user name:" << user << " password: " << password;
    }
    virtual void    killBoss()
    {
        qDebug() << this->m_name << "kill Boss!";
    }
    virtual void    upgrade()
    {
        qDebug() << this->m_name << "upgrade!";
    }

private:
    QString m_name;
    
};

class GamePlayerProxy:public IGamePlayer
{
public:
    GamePlayerProxy(IGamePlayer *player)
    {
        this->m_player = player;
    }
    virtual void    login(QString user, QString password)
    {
        this->m_player->login(user, password);
    }
    virtual void    killBoss()
    {
        this->m_player->killBoss();
    }
    virtual void    upgrade()
    {
        this->m_player->upgrade();
    }

private:
    IGamePlayer *m_player;
};

int main()
{
    IGamePlayer *player = new GamePlayer("Tom");
    IGamePlayer *proxy  = new GamePlayerProxy(player);
    QString time = QString::fromUtf8("HH:mm:ss.zzz");
    qDebug() << QDateTime::currentDateTime().toString(time);
    proxy->login("Tom", "password");            
    proxy->killBoss();
    proxy->upgrade();
    qDebug() << QDateTime::currentDateTime().toString(time);        
                
    return 0;
}


四、代理模式的应用

优点：

  •  职责清晰。真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件事务，附带的结果就是编程简洁清晰。
  •  高扩展性。具体主题角色是随时都会发生变化的，只要它实现了接口，代理类就可以在不做任何修改的情况下使用。
  •  智能化。动态代理实现了智能化。


五、代理模式的扩展


4.1. 网络代理服务器分类：

透明代理和普通代理。透明代理是用户不用设置代理服务器地址，就可以直接访问，也就是说代理服务器对用户来说是透明的，不用知道它的存在的；普通代理则是需要用户自己设置代理服务器的IP地址，用户必须知道代理存在。设计模式中的代理与之类似。普通代理就是我们要知道代理的存在，也就是类似 GamePlayerProxy 这个类的存在，然后才能访问；强制代理则是调用者直接调用真实角色，而不用关心代理是否存在，其代理的产生是由真实角色决定的。

 

4.2. 普通代理

要求客户端只能访问代理角色，而不能访问真实角色。对上述例子做扩展，我自己作为一个游戏玩家，我自己不练级了，也就是使用时不能直接new 一个 GamePlayer 对象，它必须由 GamePlayerProxy 来进行模拟场景。

 

示例四：普通代理

①类图12-4

②. 类图说明：

仅仅修改了两个实现类的构造函数。GamePlayer 的构造函数增加了 gamePlayer 参数，而代理角色只要传入代理者名字即可，不需要说是替哪个对象做代理。在这种情况下，调用者只知道代理存在就可以，不用知道代理了谁，屏蔽了真实角色的变更对高层模块的影响，真实的主题角色想怎么改就怎么改，对高层模块没有任何影响，只要实现了接口所对应的方法。

 

③. 代码清单12-4:

////////    **********  4. 普通代理模式，代码清单12-4:***************//
#include <QDebug>
#include <QDateTime>

class IGamePlayer
{
public:
    virtual void    login(QString user, QString password) = 0;
    virtual void    killBoss()                            = 0;
    virtual void    upgrade()                             = 0;
};

class GamePlayer:public IGamePlayer
{
public:
    GamePlayer(IGamePlayer *gameplayer, QString name)
    {
        if (gameplayer != nullptr)
        {
            this->m_name = name;
        } 
    }
    virtual void    login(QString user, QString password)
    {
        qDebug() << "user name:" << user << " password: " << password;
    }
    virtual void    killBoss()
    {
        qDebug() << this->m_name << "kill Boss!";
    }
    virtual void    upgrade()
    {
        qDebug() << this->m_name << "upgrade!";
    }

private:
    QString m_name;
    
};

class GamePlayerProxy:public IGamePlayer
{
public:
    GamePlayerProxy(QString name)
    {
        this->m_player = new GamePlayer(m_player, name);
    }
    virtual void    login(QString user, QString password)
    {
        this->m_player->login(user, password);
    }
    virtual void    killBoss()
    {
        this->m_player->killBoss();
    }
    virtual void    upgrade()
    {
        this->m_player->upgrade();
    }

private:
    IGamePlayer *m_player;
};

int main()
{
    IGamePlayer *proxy  = new GamePlayerProxy("Tom");
    QString time = QString::fromUtf8("HH:mm:ss.zzz");
    qDebug() << QDateTime::currentDateTime().toString(time);
    proxy->login("Tom", "password");            
    proxy->killBoss();
    proxy->upgrade();
    qDebug() << QDateTime::currentDateTime().toString(time);        
                
    return 0;
}


4.3. 强制代理

要求必须通过真实角色查找到代理角色，否则不能访问。不论是否是通过代理类还是通过直接new一个主题角色类，都不能访问，只有通过真实角色指定的代理类才可以访问，也就是说由真实角色管理代理角色。也即，高层模块new了一个真实角色对象，返回的却是代理角色。


示例五：强制代理

①  类图12-5

 

②  类图说明：

在接口上增加了一个getProxy方法，真实角色GamePlayer可以指定一个自己的代理，除了代理外谁都不能访问。
增加了一个私有方法，检查是否是自己指定的代理，是指定的代理则允许访问，否则不允许访问。
代理角色可以再次被代理，查找代理的方法这里就返回了自己的实例。

访问一：
    IGamePlayer *player = new GamePlayer("Tom");
    player->login("Tom", "password");            
    player->killBoss();
    player->upgrade();
无法访问，如果想直接访问是不可以的，需要通过代理来访问

访问二：
    IGamePlayer *player = new GamePlayer("Tom");
    IGamePlayer *proxy  = new GamePlayerProxy(player);
    proxy->login("Tom", "password");            
    proxy->killBoss();
    proxy->upgrade();
无法访问，这个代理对象是我们自己new出来的，真实对象不认，不是真实对象指定的代理。

访问三：
    IGamePlayer *player = new GamePlayer("Tom");
    IGamePlayer *proxy  = player->getProxy();
    proxy->login("Tom", "password");            
    proxy->killBoss();
    proxy->upgrade();
可以访问。强制代理的概念就是要从真实角色查找到代理角色，不允许直接访问真实角色。高层模块只要调用getProxy就可以访问真实角色的所有方法，他根本不需要产生一个代理出来，代理的管理由真实角色自己完成

 

③ 代码清单12-5:


////////    **********  5. 强制代理模式，代码清单12-5:***************//
#include <QDebug>
#include <QDateTime>

class IGamePlayer
{
public:
    virtual void    login(QString user, QString password) = 0;
    virtual void    killBoss()                            = 0;
    virtual void    upgrade()                             = 0;
    virtual IGamePlayer *getProxy()                       = 0;
};

class GamePlayerProxy:public IGamePlayer
{
public:
    GamePlayerProxy(IGamePlayer *gamePlayer)
    {
        this->m_player = gamePlayer;
    }
    virtual void    login(QString user, QString password)
    {
        this->m_player->login(user, password);
    }
    virtual void    killBoss()
    {
        this->m_player->killBoss();
    }
    virtual void    upgrade()
    {
        this->m_player->upgrade();
    }
    virtual IGamePlayer *getProxy()
    {
        return this;
    }

private:
    IGamePlayer *m_player;
};

class GamePlayer:public IGamePlayer
{
public:
    GamePlayer(QString name)
    {
        this->m_proxy = nullptr;
        this->m_name = name;
    }
    virtual void    login(QString user, QString password)
    {
        if (this->isProxy())
        {
            qDebug() << "user name:" << user << " password: " << password;
        }
        else
        {
            qDebug() << "Please find the proxy!";
        }
    }
    virtual void    killBoss()
    {
        if (this->isProxy())
        {
            qDebug() << this->m_name << "kill Boss!";
        }
        else
        {
            qDebug() << "Please find the proxy!";
        }
    }
    virtual void    upgrade()
    {
        if (this->isProxy())
        {
            qDebug() << this->m_name << "upgrade!";
        }
        else
        {
            qDebug() << "Please find the proxy!";
        } 
    }
    virtual IGamePlayer* getProxy()
    {
        this->m_proxy = new GamePlayerProxy(this);
        return this->m_proxy;
    }
private:
    bool    isProxy()
    {
        if (this->m_proxy == nullptr)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

private:
    QString      m_name;
    IGamePlayer *m_proxy;
};



int main()
{
    IGamePlayer *player = new GamePlayer("Tom");
    IGamePlayer *proxy  = player->getProxy();
    QString time = QString::fromUtf8("HH:mm:ss.zzz");
    qDebug() << QDateTime::currentDateTime().toString(time);
    proxy->login("Tom", "password");            
    proxy->killBoss();
    proxy->upgrade();
    qDebug() << QDateTime::currentDateTime().toString(time);        
                
    return 0;
}

 

4.4. 代理是有个性的

一个类可以实现多个接口，完成不同任务的整合。也就是说代理类不仅仅可以实现主体接口，也可以实现其他接口完成不同的任务，而且代理的目的是在目标对象方法的基础上做增强，这种增强的本质通常就是对目标对象的方法进行拦截和过滤。

 

示例六：代理的个性

① 类图12-6

 

② 代码清单12-6:

////////    **********  6. 代理类的个性，代码清单12-6:***************//
#include <QDebug>
#include <QDateTime>

class IProxy
{
public:
    virtual void count() = 0;
};

class IGamePlayer
{
public:
    virtual void    login(QString user, QString password) = 0;
    virtual void    killBoss()                            = 0;
    virtual void    upgrade()                             = 0;
    virtual IGamePlayer *getProxy()                       = 0;
};

class GamePlayerProxy:public IGamePlayer, public IProxy
{
public:
    GamePlayerProxy(IGamePlayer *gamePlayer)
    {
        this->m_player = gamePlayer;
    }
    virtual void    login(QString user, QString password)
    {
        this->m_player->login(user, password);
    }
    virtual void    killBoss()
    {
        this->m_player->killBoss();
    }
    virtual void    upgrade()
    {
        this->m_player->upgrade();
        this->count();
    }
    virtual IGamePlayer *getProxy()
    {
        return this;
    }
    virtual void count(){qDebug() << "update count is : $150";}

private:
    IGamePlayer *m_player;
};

class GamePlayer:public IGamePlayer
{
public:
    GamePlayer(QString name)
    {
        this->m_proxy = nullptr;
        this->m_name = name;
    }
    virtual void    login(QString user, QString password)
    {
        if (this->isProxy())
        {
            qDebug() << "user name:" << user << " password: " << password;
        }
        else
        {
            qDebug() << "Please find the proxy!";
        }
    }
    virtual void    killBoss()
    {
        if (this->isProxy())
        {
            qDebug() << this->m_name << "kill Boss!";
        }
        else
        {
            qDebug() << "Please find the proxy!";
        }
    }
    virtual void    upgrade()
    {
        if (this->isProxy())
        {
            qDebug() << this->m_name << "upgrade!";
        }
        else
        {
            qDebug() << "Please find the proxy!";
        } 
    }
    virtual IGamePlayer* getProxy()
    {
        this->m_proxy = new GamePlayerProxy(this);
        return this->m_proxy;
    }
private:
    bool    isProxy()
    {
        if (this->m_proxy == nullptr)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

private:
    QString      m_name;
    IGamePlayer *m_proxy;
};



int main()
{
    IGamePlayer *player = new GamePlayer("Tom");
    IGamePlayer *proxy  = player->getProxy();
    QString time = QString::fromUtf8("HH:mm:ss.zzz");
    qDebug() << QDateTime::currentDateTime().toString(time);
    proxy->login("Tom", "password");            
    proxy->killBoss();
    proxy->upgrade();
    qDebug() << QDateTime::currentDateTime().toString(time);        
                
    return 0;
}

③ 代码说明

代理类可以为真实角色预处理消息、过滤消息、消息转发、时候处理消息等功能。一个代理类，可以代理多个真实角色，并且真实角色之间可以有耦合关系。

 

参考文献《秦小波. 设计模式之禅》（第2版） (华章原创精品). 机械工业出版社

C++设计模式——Proxy代理模式
程序员与背包客_CoderZ
06-14 1324
C++设计模式入门
C++设计模式——代理模式（proxy pattern）
净无邪博客
09-23 666
一、原理讲解 代理模式也可以称作为委托，对对象的业务的委托。 1.1意图 为其它对象提供一种代理，以控制对这个对象的访问。 1.2应用场景 1.2.1远程代理（remote proxy） 为一个对象在不同的地址空间提供局部代表； 1.2.2虚代理（virtual proxy） 根据需要创建开销很大的对象； 1.2.3保护代理（protection proxy） 控制对原始对象的访问。保护代理用于对象应该有不同的访问权限的时候； 1.2.4智能引用（smart reference） 对指向实际对
cocos2dx 3.3 跑酷游戏 人物的创建
fztfztfzt的专栏
10-22 932
人物的创建 之前先建个头文件用来放一些设定： 注意新建项的存放位置是classes文件夹下 游戏中只有一个人物，所以打算使用单例模式，模仿Director建立静态的getInstance（）； 人物应该有跑动，跳跃，落下，死亡4个状态，目前是这4个，有可能会增加； 人物跳跃时y速度和加速度很难定，试了很多次，现在的效果还不是
C++ 设计模式——代理模式
Echo_HY的博客
03-05 614
代理模式指代理控制对其他对象的访问，也就是代理对象控制对原对象的引⽤。代理模式的结构包括⼀个是真正的你要访问的对象(⽬标类)、⼀个是代理对象。⽬标对象与代理对象实 现同⼀个接⼝，先访问代理类再通过代理类访问⽬标对象。• 静态代理指的是，在编译时就已经确定好了代理类和被代理类的关系。也就是说，在编译时就已经 确定了代理类要代理的是哪个被代理类。• 动态代理指的是，在运⾏时才动态⽣成代理类，并将其与被代理类绑定。这意味着，在运⾏时才能 确定代理类要代理的是哪个被代理类。
C++设计模式——代理模式
Abieai的博客
10-14 414
这篇文章主要实现了代理模式。
C++设计模式结构型模式———代理模式
最新发布
无敌岩雀的博客
11-09 1612
代理模式的使用方式有很多，延迟初始化 （虚拟代理）。如果有一个偶尔使用的重量级服务对象， 一直保持该对象运行会消耗系统资源时， 可使用代理模式。无需在程序启动时就创建该对象， 可将对象的初始化延迟到真正有需要的时候。访问控制：如果你只希望特定客户端使用服务对象， 这里的对象可以是操作系统中非常重要的部分， 而客户端则是各种已启动的程序 （包括恶意程序）， 此时可使用代理模式。代理可仅在客户端凭据满足要求时将请求传递给服务对象。代理模式和装饰模式有类似之处，但是这两个模式要解决的问题不同或者说立场不同。
【Proxy模式】C++设计模式——代理模式
不负AC不负卿的博客
07-30 2740
C++代理模式，Proxy模式，本文以现实社会例子来阐述该模式，通过对代理模式的概括、总结、代码对比分析来帮助读者了解该模式
C++设计模式——适配器模式
Abieai的博客
10-14 739
设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。主要实现了适配器模式。
C++设计模式结构型模式———装饰模式
无敌岩雀的博客
11-02 1597
装饰模式是一种结构型设计模式， 允许你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。 该模式展现出了运行时的一种扩展能力，以及比继承更强大和灵活的设计视角和设计能力，甚至在有些场合下，不使用该模式很难解决问题。
C++ 设计模式——设计模式总结
qq_68194402的博客
09-03 1219
设计模式是软件设计中常见问题的典型解决方案。它们是经过反复验证的、可重用的代码设计经验，用于解决在特定情境下反复出现的软件设计问题。
C++设计模式——代理模式(Proxy Pattern)
leonardohaig的博客
09-20 2229
C++设计模式——代理模式(Proxy Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——代理模式(Proxy Pattern)目录定义代码示例总结优缺点对比参考资料 定义 The proxy design pattern allows you to provide an interface to other objects by creating a wrapper class as the proxy. The wrapper class, which is the pr
设计模式C++版
06-13
设计模式C++版文档主要聚焦于面向对象设计与分析的核心——设计模式，并以C++语言实现为示范。这份文档详尽阐述了23种GoF（Gang of Four）设计模式，并结合具体的C++源码示例，旨在帮助读者深入理解并掌握这些设计...
设计模式 —— 里氏替换原则
Jecklin_online的博客
09-13 6145
前言 ● 第一种定义，也是最正宗的定义：如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有的对象o1都代换成o2 时，程序P的行为没有发生变化，那么类型 S 是类型 T 的子类型。 ● 第二种定义：所有引用基类的地方必须能透明地使用其子类的对象。 第二个定义是最清晰明确的，通俗点讲，只要父类能出现的地方子类就可以出现，而且替换为子类也不会 产生任何错误或异...
设计模式 c++版（11）——策略模式
Jecklin_online的博客
09-26 968
定义： 定义一组算法，将每个算法都封装起来，并且使他们之间可以互换 示例一：策略模式（通用版） 1. 类图18-3   2. 类图说明 策略模式使用的就是面向对象的继承和多态机制 Context 封装角色。也叫上下文角色，起承上启下的封装作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。 Strategy 抽象策略角色。策略、算法家族的抽象，通常为借口，定义每个策略或算...
设计模式 c++版（16）——门面模式
Jecklin_online的博客
10-09 636
定义： 要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用（门面模式也叫做外观模式）。 示例一：门面模式（通用版） 1. 类图23-4   2. 类图说明 Subsystem Classes 是子系统所有类的简称，它可以代表几十个对象的集合。门面对象时外界访问子系统内部的唯一通道。   3. 门面模式结构图 23-5 ...
设计模式 c++版（21）——桥梁模式
Jecklin_online的博客
10-10 483
定义：将抽象和实现解耦，使得两者可以独立地变化。 示例一：桥梁模式（通用版） 1. 类图 29-4   2. 类图说明 Abstraction 抽象化角色。主要职责是定义出该角色的行为，同时保存一个对实现化角色的引用，该角色一般是抽象类。 Implementor 实现化角色。它是接口或抽象类，定义角色必须的行为和属性。 RefinedAbstraction 修正抽象化角色。它引用实例...
设计模式 c++版（2）——工厂模式
Jecklin_online的博客
09-19 462
定义： 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类 示例一：工厂方法模式（通用版） 1.类图8-2 2. 类图说明： Product                抽象产品类，负责定义产品的共性，实现对事物最抽象的定义Creator                 抽象创建类，即抽象工厂ConcreteCreator  具体实现工厂，创建...
设计模式 c++版（9）——责任链模式
Jecklin_online的博客
09-26 433
定义： 使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止 示例一：责任链模式（通用版） 1. 类图16-4   2. 代码清单 ////////////////// ********** 3. 责任链模式（通用版），代码清单16-3:***************// enum ...
设计模式 c++版（4）——模板方法模式
Jecklin_online的博客
09-21 398
定义： 定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 示例一：模板方法模式（通用版） 1. 类图10-3 2. 类图说明： AbstractClass 叫抽象模板，他的方法分为两类： 基本方法：即基本操作，是由子类实现的方法，并且在模板方法被调用。 模板方法：可以有一个或几个，一般是一个具体方法，即一个框架，实现对...
C++设计模式实战：代理模式下的文本查找器
本例代码不仅是初学者学习C++的一个很好的练习，而且其背后的设计模式——代理模式——对于加深理解面向对象设计原理也有很大帮助。 首先，代理模式是一种结构型设计模式，它为其他对象提供一种代理以控制对这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值