大话设计模式--代理模式 proxy

1. 代理模式: 为其他对象提供一种代理以控制这个对象的访问。

代理模式使用场合：

a. 远程代理， 为一个对象在不同的地址空间提供局部代理，隐藏一个对象存在于不同地址空间的事实。如.net中WebService的应用。

b. 虚拟代理， 根据需要创建开销很大的对象， 通过它来存放实例化需要很长时间的真是对象。 如浏览器中 大图片的 显示过程，先显示一个代理，下载完成后在显示真实。

c. 安全代理， 用来控制真实对象访问时的权限。

d. 智能指引， 当调用真实对象时， 代理处理另一些事。

实例：

givegift.h  代理和追求者总有的特征作为接口

#ifndef GIVEGIFT_H
#define GIVEGIFT_H

class GiveGift
{
public:
    GiveGift();
    void virtual giveDolls()=0;
    void virtual giveFlowers()=0;
    void virtual giveChocolate()=0;
};

#endif // GIVEGIFT_H

givegift.cpp

#include "givegift.h"

GiveGift::GiveGift()
{
}

pursuit.h 追求者，真正的给予者

#ifndef PURSUIT_H
#define PURSUIT_H

#include "givegift.h"
#include <string>
using namespace std;

class Pursuit : public GiveGift
{
public:
    Pursuit(string mmName);
    void giveDolls();
    void giveFlowers();
    void giveChocolate();

private:
    string mmName;
};

#endif // PURSUIT_H

pursuit.cpp

#include "pursuit.h"
#include <iostream>
using namespace std;

Pursuit::Pursuit(string mmName)
{
    this->mmName = mmName;
}

void Pursuit::giveDolls()
{
    cout << mmName << " give you a doll " << endl;
}

void Pursuit::giveFlowers()
{
    cout << mmName << " give you a flower " << endl;
}

void Pursuit::giveChocolate()
{
    cout << mmName << " give you a chocolate " << endl;
}

proxy.h

#ifndef PROXY_H
#define PROXY_H

#include "pursuit.h"

class Proxy
{
public:
    Proxy(string mmName);
    void giveDolls();
    void giveFlowers();
    void giveChocolate();

private:
    Pursuit *gg;
};

#endif // PROXY_H

proxy.cpp

#include "proxy.h"

Proxy::Proxy(string mmName)
{
    gg = new Pursuit(mmName);
}

void Proxy::giveDolls()
{
    gg->giveDolls();
}

void Proxy::giveFlowers()
{
    gg->giveFlowers();
}

void Proxy::giveChocolate()
{
    gg->giveChocolate();
}

main.cpp

#include <iostream>
#include "proxy.h"

using namespace std;

int main()
{
    cout << "Proxy test " << endl;

    Proxy *proxy = new Proxy("nvshen");
    proxy->giveDolls();
    proxy->giveFlowers();
    proxy->giveChocolate();

    return 0;
}

---------------------------------------  转载  ----------------------------------------

考虑一个可以在文档中嵌入图形对象的文档编辑器。有些图形对象的创建开销很大。但是打开文档必须很迅速，因此我们在打开文档时应避免一次性创建所有开销很大的对象。这里就可以运用代理模式，在打开文档时，并不打开图形对象，而是打开图形对象的代理以替代真实的图形。待到真正需要打开图形时，仍由代理负责打开。这是[DP]一书上的给的例子。下面给出代理模式的UML图。

简单实现如下：

class Image
{
public:
	Image(string name): m_imageName(name) {}
	virtual ~Image() {}
	virtual void Show() {}
protected:
	string m_imageName;
};
class BigImage: public Image
{
public:
	BigImage(string name):Image(name) {}
	~BigImage() {}
	void Show() { cout<<"Show big image : "<<m_imageName<<endl; }
};
class BigImageProxy: public Image
{
private:
	BigImage *m_bigImage;
public:
	BigImageProxy(string name):Image(name),m_bigImage(0) {}
	~BigImageProxy() { delete m_bigImage; }
	void Show()
	{
		if(m_bigImage == NULL)
			m_bigImage = new BigImage(m_imageName);
		m_bigImage->Show();
	}
};

客户调用：

1. int main()
2. {
3. Image *image = new BigImageProxy("proxy.jpg"); //代理
4. image->Show(); //需要时由代理负责打开
5. delete image;
6. return 0;
7. }