Re: 'withing' problem [code generation]

["Matthew Heaney" <mheaney@on2.com>]

"David Crocker" <dcrocker@imsltd.com> wrote in message
news:3bfa84ca$0$8514$ed9e5944@reading.news.pipex.net...
> It's not hard to come up with a system that makes the order of C++ include
> files unimportant. Our product currently generates C++ (we would like to
> generate Ada, which is why I started this thread) so we needed just such a
> scheme.

You have to forward declare the types in C++ too:

//chicken.hpp
class Egg;
class Chicken
{
public:
   void lay(Egg&);
};

//egg.hpp
class Chicken;
class Egg
{
public:
   void layer(Chicken*&) const;
};


> The nicest solution is the one used by Java (and by our own product) - no
> restriction at all on forward referencing classes/types, or on packages
> referring to each other (except for absurd cases like 2 classes inheriting
> from each other). This is the way all programming languages should go,
IMO.

That's swell.  Why don't you post this on comp.lang.c++ and see what the
reaction is.  My hunch is that most C++ programmers won't be sympathetic.

You cannot compare static languages like Ada95 and C++ to dynamic languages
like Java or Eiffel.  They were designed to solve different problems, and
hence reflect different philosophies.

> Forward-declarations should be considered obsolete - they only exist to
make
> life easier for the compiler writer, and compiler technology has come a
long
> way now.

It's called "type-checking."  The rule is that an entity has to be declared
before being used.  This is a deliberate feature of the language, and it's
there because the language designer wanted it to be there.  It has nothing
to do with compiler technology (since you could have easily designed the
language without that feature).