Re: Partially complete types

On Apr 15, 4:26 am, Greg Herlihy <gre...@[EMAIL PROTECTED]
> wrote:
> Instead, the Library interface should declare IParameter along these
> lines:
>     class Component
> [...]
>        virtual IParameter* get_parameter ();
> [...]
>     class ComponentImpl : public Component
>        virtual Parameter* get_parameter ()

Yep, this will work due to covariant return types, which allows you to
strengthen the type info. But it is a lot of scaffolding.

A simpler solution is to just create two interfaces; one for external
use and one for internal use:

   class Component {
   public:
     class IParameter {...};
     virtual IParameter* get_parameter ();
   private:
     class Parameter;
     Parameter* private_get_parameter ();
     ...
   };

Implementation:

   class Component::Parameter : Component::IParameter {
     ...
   };
   IParameter* Component::get_parameter ()
     {return private_get_parameter ();}

This works and has less implications on the Component class hierarchy
compared to your solution. But it is still scaffolding. The interface
of Component is duplicated and one implemented in terms of the other.
It would be much more straight-forward to be able to tell the compiler
partial type information. Here's that hypothetical solution again:

   class Component {
   public:
     class IParameter {...};
     class Parameter : public IParameter; // partial type completion
     virtual Parameter* get_parameter ();
   private:
     ...
   };

But is it possible/easy to implement? Does the compiler know enough
after seeing the partial type to use Parameter through the base class
IParameter?

Regards,
Vidar Hasfjord

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