Re: Virtualization of a 'protected interface'

From:

Michael Doubez <michael.doubez@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Mon, 4 May 2009 08:13:22 -0700 (PDT)

Message-ID:

<a724a79e-1669-434a-956b-a085b2a37f22@s20g2000vbp.googlegroups.com>

On 4 mai, 16:02, tristan <tomorrow_is_g...@hotmail.com> wrote:

I am afraid you misunderstand the meaning of proxy.
Proxy is only a representative for a real class entity, or it could be
responsible for some POST-DO / AFTER-DO operations.

And ?

Still it does break encapsulation.

InternalService() is protected, that indicates it is available for
MyBase inheritance hierarchy, but Proxy shouldn't be within that hierarch=

y.

In your post, MyProxy inherits from MyBase.

So this design is irrational. At least, MyProxy shouldn't inherit from
MyBase.

In that case, create an internal class in Proxy with a static method
that invoke MyBase::DoInternalService().

class MyProxy
{private:
   struct BreakMyBaseEncaps: MyBase
   {
    static void do_it(MyBase& b)
    {
      DoInternalService(b);
    }
   };
//...
   void InternalService()
   {
     BreakMyBaseEncaps::do_it(Backend);
   }
   //...
};

PS: don't top post

--
Michael

Michael Doubez :

On 3 mai, 23:17, Marcel M=FCller <news.5.ma...@spamgourmet.org> 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, excep=

for making MyBase::InternalService public?

The idea behind that is, that references to MyBase objects (MyProxy) c=

override some properties of the underlying instance and different
references may override different properties. The common implementatio=

part in MyBase contains a framework to deal with change notifications
and asynchronously requested informations. If MyProxy overrides a
property it must also intercept the methods to obtain that information=

But these Methods should only be called by the framework in MyBase and
by proxy classes.

An ugly way to do it is to add a static member function in MyBase that
calls InternalService on its parameter:

class MyBase
{
  protected:
  //...
  static void DoInternalService(MyBase& b)
  {
   b.InternalService();
  }
  //...
};

And use it in MyImplementation:
  protected:
    void InternalService()
    {
      DoInternalService(Backend);
    }

Note that this kind of design if brittle and it breaks encapsulation.

You can also use a static function to return the pointer on the member
function and use it to call InternalService.