=?windows-1252?Q?Re=3A_Abstract_classes_=93interfaces=94_and_const_meth?= =?windows-1252?Q?ods?=

I don't have a concrete sample, but I started to think about this in
the context of remote object access (Like DCOM)
I like the interface model in this situation because doesn't matter if
you have a local or a remote object you can keep the same code.
The object pointed by the interface will refer to the recipient and
the function itself is the message.
When the object is remote the interface is talking with a proxy of the
real object like an invisible postman. Also in the server side we are
going to have another postman to translate the message and delivery to
the real object.
When the object is local we talk with the real object directly using
an interface contract.

Should the postman itself have the same contract?
Should interfaces be declared without const?

If the interface is declared with const, we can implement the postman
using mutable data members. He can update the delivery time for
instance, or cache something.
If the interface is declared without const we are penalizing final
objects and they might be or not accessed through the interface
directly.

Also, the second postman can work just as an adapter.

struct Interface { virtual int GetSize() = 0; };
struct Recipient { const int Size() const { return 1; } };
struct Postman2 : public Interface
{
  Recipient * m_p;
  virtual int GetSize() { return m_p->Size(); }
};
Calling const function from non const object pointer is natural.
But this is not true for virtual functions.

I have seem more non const virtual functions. I guess the implementers
don't want to be too rigid in their contracts. (This also reminds me
exception specification contracts)
For instance, let's take a "Draw" function in a "Shape" class. It can
be const or not. Having such mutable virtual function the
implementers could decide if they prefer to implement as a const or
non const Draw. However, it would be possible to call const version
from non const (less restrictive) function.

Maybe this discussion could be broken in different cases, but I am
especially curious about this context of remoting object access.

In a remoting environment should the messages take const in account?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]