| Thinking in C++ Vol 2 - Practical Programming |
|
Prev |
Home |
Next |
Proxy: fronting for another object
If we implement Proxy using the above diagram, it looks like
this:
//: C10:ProxyDemo.cpp
// Simple demonstration of the Proxy pattern.
#include <iostream>
using namespace std;
class ProxyBase {
public:
virtual void f() = 0;
virtual void g() = 0;
virtual void h() = 0;
virtual ~ProxyBase() {}
};
class Implementation : public ProxyBase {
public:
void f() { cout <<
"Implementation.f()" << endl; }
void g() { cout <<
"Implementation.g()" << endl; }
void h() { cout <<
"Implementation.h()" << endl; }
};
class Proxy : public ProxyBase {
ProxyBase* implementation;
public:
Proxy() { implementation = new Implementation(); }
~Proxy() { delete implementation; }
// Forward calls to the implementation:
void f() { implementation->f(); }
void g() { implementation->g(); }
void h() { implementation->h(); }
};
int main() {
Proxy p;
p.f();
p.g();
p.h();
} ///:~
In some cases, Implementation doesn t need the same
interface as Proxy as long as Proxy is somehow speaking for the
Implementation class and referring function calls to it, then the basic
idea is satisfied (note that this statement is at odds with the definition for
Proxy in GoF). However, with a common interface you are able to do a drop-in
replacement of the proxy into the client code the client code is written to
talk to the original object, and it doesn t need to be changed in order to
accept the proxy (This is probably the key issue with Proxy). In addition, Implementation
is forced, through the common interface, to fulfill all the functions that Proxy
needs to call.
The difference between Proxy and State is in the problems
that are solved. The common uses for Proxy as described in GoF are:
1. Remote proxy. This proxies for an object in a different
address space. This is implemented by some remote object technologies.
2. Virtual proxy. This provides lazy initialization to create expensive objects on demand.
3. Protection proxy. Used when you don t want the client
programmer to have full access to the proxied object.
4. Smart reference. To add additional actions when the
proxied object is accessed. Reference counting is an example: this keeps
track of the number of references that are held for a particular object, in
order to implement the copy-on-write idiom and prevent object aliasing. A simpler
example is counting the calls to a particular function.
| Thinking in C++ Vol 2 - Practical Programming |
|
Prev |
Home |
Next |
