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

• 運行結果

赫敏 這是送你的花

赫敏 這是送你的洋娃娃

赫敏 這是送你的巧克力

優點

模式的優點

• 從模式的動機我們能看出來幾個好處：
  • 可以隱藏需要代理的對象
  • 控制對象的訪問權限
  • 可以通過代理對象獲取自己需要的對象

缺點

模式的缺點