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