代理模式（c++实现）

代理模式

目录

• 代理模式
  • 模式定义
  • 模式动机
  • UML类图
  • 源码实现
  • 优点
  • 缺点

模式定义

代理模式（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;
}

• 运行结果

赫敏 这是送你的花

赫敏 这是送你的洋娃娃

赫敏 这是送你的巧克力

优点

模式的优点

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

缺点

模式的缺点