Re: Virtualization of a 'protected interface'

From:

blargg.ei3@gishpuppy.com (blargg)

Newsgroups:

comp.lang.c++

Date:

Sun, 03 May 2009 18:20:36 -0500

Message-ID:

<blargg.ei3-0305091820370001@192.168.1.4>

Marcel Muller wrote:

I have an abstract base class that provides public and protected pure
functions.

class MyBase
{protected:
   virtual void InternalService() = 0;

  public:
   virtual void PublicService() = 0;

   void CommonImplementation()
   { // Do something that depends on InternalService...
     InternalService();
   }
};

class MyImplementation : public MyBase
{protected:
   void InternalService();

  public:
   void PublicService();
};

class MyProxy : public MyBase
{private:
   MyBase& Backend;

  protected:
   void InternalService()
   { // Modify Backend.InternalService somehow...
     Backend.InternalService(); // <-- access denied
   }

  public:
   MyProxy(MyBase& backend) : Backend(backend) {}

   void PublicService()
   { // Modify Backend.PublicService somehow...
     Backend.PublicService();
   }
};

Unfortunately MyProxy cannot access the protected members of /another/
MyBase instance. Is there another way to do something like that, except
for making MyBase::InternalService public?

[...]

Write a general proxy class that's a friend of MyBase, then derive your
specific MyProxy (and others) from it:

class MyBase {
    ...
    friend class Proxy;
};

class Proxy : MyBase {
    MyBase* backend;
protected:
    void set_backend( MyBase* b ) { backend = b; }
    virtual void InternalService() { backend.InternalService(); }

public:
    virtual void PublicService() { backend.PublicService(); }
};

class MyProxy : public Proxy {
protected:
   void InternalService()
   {
        // ...
        Proxy::InternalService();
        // ...
   }

public:
   MyProxy(MyBase& backend) { set_backend( backend ); }

   void PublicService()
   {
        // ...
        Proxy::PublicService();
        // ...
   }
};