Proxy Design Pattern in C++

Proxy Design Pattern is a Structural Design Pattern that allows us to provide a substitute or we can say a placeholder for another object. In Proxy Design Pattern, a class represents the functionality of another class. A proxy receives client requests, does some work (access control, caching, etc.) and then passes the request to a service object (the original object).

Proxy Design Pattern is used when we need to create a wrapper for an object to control access to it. It is also used to add additional functionality to an object without changing its code.

Take the following example. In the image, the man at the gate talks to visitors for the queen because she’s busy. He passes messages and only lets the right ones in — kind of like a helper who speaks for her. That’s what a proxy does.

Types of Proxy Design Pattern

Following are the different types of Proxy Design Pattern −

• Remote Proxy − Lets you use something that’s far away, maybe on another computer.
• Virtual Proxy − Creates the real thing only when you actually need it, so it saves time and memory.
• Protection Proxy − Checks if you’re allowed to use something before giving you access.
• Caching Proxy − Stores results and gives them back quickly if you ask for the same thing again.
• Logging Proxy − Keeps a record of what happens when you use the real object.
• Synchronization Proxy − Makes sure only one person can use something at a time to avoid clashes.
• Smart Reference Proxy − Adds a few extra steps when you use something, like counting how many times it’s used or loading it only when needed.

Components of Proxy Design Pattern

• Subject − The basic rules or actions that both the real object and the helper use.
• RealSubject − The real object that does the main job.
• Proxy − The helper that talks for the real object and controls who can use it.

Implementation of Proxy Design Pattern in C++

We will implement a simple example of Proxy Design Pattern in C++. In this example, we will create a proxy for a Database class that simulates a connection to a database. The proxy will control access to the database and add caching functionality.

Steps to Implement Proxy Design Pattern

Follow the steps below to implement the Proxy Design Pattern in C++

• Define the Subject interface that declares the common operations for both the real object and the proxy.
• Create the RealSubject class that implements the Subject interface and simulates a database connection.
• Create the Proxy class that also implements the Subject interface and controls access to the RealSubject. It will add caching functionality.
• Use the Proxy class in the client code to access the database.

C++ Code for Proxy Design Pattern

Below is the C++ code that demonstrates the Proxy Design Pattern −

Here, the DatabaseProxy class acts as a middleman for the RealDatabase class. It saves the result of the first query and gives back the saved result if you ask again, showing how a proxy can cache data.

#include <iostream>
#include <string>
using namespace std;

// Subject Interface
class Database {
public:
   virtual string query(const string& sql) = 0;
   virtual ~Database() {}
};

// RealSubject Class
class RealDatabase : public Database {
public:
   string query(const string& sql) override {
      // Simulate a database query
      return "Results for query: " + sql;
   }
};

// Proxy Class
class DatabaseProxy : public Database {
private:
   RealDatabase* realDatabase;
   string cachedResult;
   bool isCached;
public:
   DatabaseProxy() : realDatabase(nullptr), isCached(false) {}
   string query(const string& sql) override {
      if (!isCached) {
         if (realDatabase == nullptr) {
            realDatabase = new RealDatabase();
         }
         cachedResult = realDatabase->query(sql);
         isCached = true;
      } else {
         cout << "Returning cached result." << std::endl;
      }
      return cachedResult;
   }
   ~DatabaseProxy() {
      delete realDatabase;
    }
};

// Client Code
int main() {
   Database* db = new DatabaseProxy();

   // First query - will access the real database
   cout << db->query("SELECT * FROM users") << endl;

   // Second query - will return cached result
   cout << db->query("SELECT * FROM users") << endl;

   delete db;
   return 0;
}

Following is the output of the above code −

Results for query: SELECT * FROM users
Returning cached result.
Results for query: SELECT * FROM users

Pros and Cons of Proxy Design Pattern

Following are the advantages and disadvantages of using the Proxy Design Pattern −

When to Use Proxy Design Pattern?

Following are some scenarios where you might want to use the Proxy Design Pattern −

• Control who can use something.
• Add saving results or keeping records without changing the main object.
• Delay making the real thing until it is needed.
• Keep something safe from people who shouldn’t use it.
• Manage how and when something is used.

Real-World Applications of Proxy Design Pattern

Following are some real-world applications of the Proxy Design Pattern −

Conclusion

In this chapter, you learned what the Proxy Design Pattern is, how it works, and where you can use it. Proxy helps you control access to something and lets you add new features without changing the main object. It’s a handy way to keep things safe and organized.