代理模式(c++实现)

代理模式

模式定义

代理模式(Proxy),为其他对象提供一种代理以控制对这个对象的访问。

模式动机

  • 远程代理,也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实。
  • 虚拟代理,是根据需要创建开销很大的对象。通过他来存放实例化需要很长时间的真实对象。
  • 安全代理,用来控制真实对象访问时的权限。
  • 智能指引,是指当调用真实的对象时,代理处理另外一些事。

UML类图

源码实现

  • givegift.h
class GiveGift
{
public:
    GiveGift();
    virtual ~GiveGift();
    virtual void GiveFlow() = 0;
    virtual void GiveChocolate() = 0;
    virtual void GiveDolls() = 0;
};
  • proxy.h
#include "givegift.h"

class ConcretePeople;
class ConcreteGirl;

class Proxy : public GiveGift
{
public:
    Proxy(ConcreteGirl* girl);
    void GiveFlow() override;
    void GiveDolls() override;
    void GiveChocolate() override;

private:
    ConcretePeople*     m_People;
};

  • proxy.cpp
#include "proxy.h"
#include "concretegirl.h"
#include "concretepeople.h"

Proxy::Proxy(ConcreteGirl* girl)
{
    m_People = new ConcretePeople("小明");
    m_People->ChasingGirls(girl);
}

void Proxy::GiveFlow()
{
    if(m_People)
        m_People->GiveFlow();
}

void Proxy::GiveDolls()
{
    if(m_People)
        m_People->GiveDolls();
}

void Proxy::GiveChocolate()
{
    if(m_People)
        m_People->GiveChocolate();
}
  • concretepeople.h
#include <string>
#include "givegift.h"
#include "concretegirl.h"

class ConcretePeople : public GiveGift
{
public:
    ConcretePeople(std::string name);
    void GiveFlow() override;
    void GiveDolls() override;
    void GiveChocolate() override;

    void ChasingGirls(ConcreteGirl* girl);
private:
    std::string     m_Name;
    ConcreteGirl*       m_Girl;
};
  • concretepeople.cpp
#include <iostream>
#include "concretepeople.h"

ConcretePeople::ConcretePeople(std::string name)
    :m_Name(name)
{

}

void ConcretePeople::GiveFlow()
{
    if(m_Girl)
        std::cout << m_Girl->Name() << " 这是送你的花" << std::endl;
}

void ConcretePeople::GiveDolls()
{
    if(m_Girl)
        std::cout << m_Girl->Name() << " 这是送你的洋娃娃" << std::endl;
}

void ConcretePeople::GiveChocolate()
{
    if(m_Girl)
        std::cout << m_Girl->Name() << " 这是送你的巧克力" << std::endl;
}

void ConcretePeople::ChasingGirls(ConcreteGirl *girl)
{
    m_Girl = girl;
}
  • concreteGirl.h
#include <string>

class ConcreteGirl
{
public:
    ConcreteGirl(std::string name);
    std::string Name();
private:
    std::string     m_Name;
};
  • main.cpp
#include <iostream>
#include <memory>
#include "proxy.h"
#include "concretegirl.h"
using namespace std;

int main()
{
    std::shared_ptr<ConcreteGirl> girl = std::make_shared<ConcreteGirl>("赫敏");
    Proxy* proxy = new Proxy(girl.get());
    proxy->GiveFlow();
    proxy->GiveDolls();
    proxy->GiveChocolate();

    return 0;
}

  • 运行结果

赫敏 这是送你的花

赫敏 这是送你的洋娃娃

赫敏 这是送你的巧克力

优点

模式的优点

  • 从模式的动机我们能看出来几个好处:
    • 可以隐藏需要代理的对象
    • 控制对象的访问权限
    • 可以通过代理对象获取自己需要的对象

缺点

模式的缺点

posted @ 2020-07-16 15:16  鬼谷子com  阅读(789)  评论(0编辑  收藏  举报