Design Pattern: Proxy

Intent
   Provide a surrogate or placeholder for another object to control access to it.
   Use an extra level of indirection to support distributed, controlled, or intelligent access.
   Add a wrapper and delegation to protect the real component from undue complexity.

Problem

   You need to support resource-hungry objects, and you do not want to instantiate such objects unless and until they are actually requested by the client.

Discussion

Design a surrogate, or proxy, object that: instantiates the real object the first time the client makes a request of the proxy, remembers the identity of this real object, and forwards the instigating request to this real object. Then all subsequent requests are simply forwarded directly to the encapsulated real object.

There are four common situations in which the Proxy pattern is applicable.
   A virtual proxy is a placeholder for "expensive to create" objects. The real object is only created when a client first requests/accesses the object.
   A remote proxy provides a local representative for an object that resides in a different address space. This is what the "stub" code in RPC and CORBA provides.
   A protective proxy controls access to a sensitive master object. The "surrogate" object checks that the caller has the access permissions required prior to forwarding the request.
   A smart proxy interposes additional actions when an object is accessed. Typical uses include: 
      Counting the number of references to the real object so that it can be freed automatically when there are no more references (aka smart pointer),
      Loading a persistent object into memory when it's first referenced,
      Checking that the real object is locked before it is accessed to ensure that no other object can change it.

class RealImage
{
  int m_id;
  public:
  RealImage(int i)
  {
  m_id = i;
  cout << " $$ ctor: " << m_id << '\n';
  }
  ~RealImage()
  {
  cout << " dtor: " << m_id << '\n';
  }
  void draw()
  {
  cout << " drawing image " << m_id << '\n';
  }
};
 
// 1. Design an "extra level of indirection" wrapper class
class Image
{
  // 2. The wrapper class holds a pointer to the real class
  RealImage *m_the_real_thing;
  int m_id;
  static int s_next;
  public:
  Image()
  {
  m_id = s_next++;
  // 3. Initialized to null
  m_the_real_thing = 0;
  }
  ~Image()
  {
  delete m_the_real_thing;
  }
  void draw()
  {
  // 4. When a request comes in, the real object is
  // created "on first use"
  if (!m_the_real_thing)
  m_the_real_thing = new RealImage(m_id);
  // 5. The request is always delegated
  m_the_real_thing->draw();
  }
};
int Image::s_next = 1;
 
int main(void)
{
  Image images[5];
 
  for (int i; true;)
  {
  cout << "Exit[0], Image[1-5]: ";
  cin >> i;
  if (i == 0)
  break;
  images[i - 1].draw();
  }
}
 

Exit[0], Image[1-5]: 2
  $$ ctor: 2
  drawing image 2
Exit[0], Image[1-5]: 4
  $$ ctor: 4
  drawing image 4
Exit[0], Image[1-5]: 2
  drawing image 2
Exit[0], Image[1-5]: 0
  dtor: 4
  dtor: 2

Another Example:

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(); 
} ///:~