设计模式--结构型模式之七-Proxy

意图：

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

 

适用性：

1远程代理:为一个对象在不同的地址空间提供局部代表

2虚代理：根据需要创建开销很大的对象

3保护代理：控制对原始对象的访问，保护代理用于对象应该有不同的访问权限的时候

4智能指针：

1对指向实际对象的引用计数，当该对象没有引用时，可自动释放

2当第一次引用一个持久对象时，将它装入内存

3在访问第一个对象前，检查是否已经锁定，以确保其他对象不能改变它

效果：

Proxy模式在访问对象时引入了一定程度的间接性。根据代理的类型，附加的间接性有多种用途：

1 Remote Proxy可以隐藏一个对象存在于不同地址空间的事实

2 Virtual Proxy  可以进行最优化，根据要求创建对象

3 Protection Proxy和Smart Proxy都允许在访问一个对象时有一些附加的内务处理

4 隐藏Copy-on-write,如果拷贝没有被修改，开销没有必要。用代理延迟拷贝过程，只有当这个对象被修改的时候才对它进行copy

 

实现：

1重载C++中的存取运算符

2 Proxy不需要知道具体的实体类型

 

示例代码

Proxy.h

 

1. #include <iostream>
2. #include <string>
3. using namespace std;
4. class Point
5. {
6. public:
7.     Point():_x(0),_y(0)
8.     {
9.         cout<<"X is 0 and Y is 0"<<endl;
10.     }
11.     Point(int i,int j):_x(i),_y(j)
12.     {
13.         cout<<"X is "<<_x<<" and Y is "<<_y<<endl;
14.     }
15.     int _x;
16.     int _y;
17. };
18. class Graphic
19. {
20. public:
21.     Graphic() {cout<<"A Graphic is created"<< endl;}
22.     virtual ~Graphic() {cout<<"A Graphic is deleted"<< endl;}
23.     virtual void Draw(const Point& at)
24.     {
25.         cout<<"Draw the Graphic on X="<<at._x<<" Y="<<at._y;
26.     }
27.     char* GetImageName()
28.     {
29.       return _fileName;
30.     }
31. protected:
32.     char* _fileName;
33. };
35. class Image:public Graphic
36. {
37. public:
38.     Image(const char* file)
39.     {
40.         _fileName = strdup(file);
41.         cout<<"Generate a Image with file name is "<<_fileName <<endl;
42.     }
43.     virtual ~Image()
44.     {
45.         
46.         cout<<"Destory a Image with file name is "<<*_fileName <<endl;
47.         delete _fileName;
48.         _fileName = 0;
49.         
50.     }
52.     virtual void Draw(const Point& at)
54.     {
55.         cout<<"Draw the Image on X="<<at._x<<" Y="<<at._y;
56.     }
58. };
60. class ImageProxy:public Graphic
61. {
62. public:
63.     ImageProxy(const char* imageFile);
64.     virtual ~ImageProxy();
65.     //virtual void Draw(const Point& at);
66.     Image* GetImage();
67. private:
68.     Image* _image;
69.     char* _filename;
70. };
72. class TextDocument
73. {
74. public:
75.     TextDocument();
76.     void Insert(Graphic*);
77. };

 

Proxy.cpp

 

 

1. #include "Graphic.h"
2. #include <string>
3. #include <iostream>
4. using namespace std;
5. ImageProxy::ImageProxy(const char *Imagefile)
6. {
7.     _filename = strdup(Imagefile);
8.     _image = 0;
9.     cout<<"Create an Image Proxy;"<<endl;
10. }
11. ImageProxy::~ImageProxy()
12. {
13.     delete _filename;
14.     delete _image;
15.     cout<<"Destroy an Image Proxy;"<<endl;
16. }
17. Image* ImageProxy::GetImage()
18. {
19.     if (_image == 0)
20.     {
21.         _image = new Image(_filename);
22.     }
23.     return _image;
24. }
25. TextDocument::TextDocument()
26. {
27.     cout<<"Create an Text Document"<<endl;
28. }
29. void TextDocument::Insert(Graphic* g)
30. {
31.     cout<<"Insert an Image  in TextDocument"<<endl;
32. }

 

main.cpp

 

 

1. #include <iostream>
2. #include "Graphic.h"
3. using namespace std;
4. int main()
5. {
6.     TextDocument a;
7.     ImageProxy* b = new ImageProxy("filename");
8.     a.Insert(b);
9.     Image* c;
10.     c = b->GetImage();
11.     Point d(2,3);
12.     return 0;
13. }