Re: Two questions

["Randy Brukardt" <randy@rrsoftware.com>]

chris.danx wrote in message ...
>Hi,
>    two questions, one on exceptions and one on objects or tagged
types.
>
>Where exactly can i put an exception handler?  I read in JE's book that
you
>can put them in loop ... end loop statements after an exit statement.
I
>normally put handlers at the end of a routine, and i was supprised to
find
>you could put them elsewhere.  What i want to know is where else can i
put
>them?  In a while loop?  In a for loop?  In an if?  ... etc.


You can't add a handler to a loop, for instance. But, you can put an
exception handler on a block. And a block is a statement. So,
effectively, you can put an exception handler anywhere you can put a
statement.  For instance:

    loop
      begin
           <stuff..>
     exception
           ....
     end;
   end loop;


>The second is to do with tagged types.  Sometimes it is suggested that
you
>put your 'create routine' -- the initialisation routine -- in a nested
>package.  Others suggest putting it in the same package as the tagged
type.
>
>Example
>
>package something_cool is
>
>    type cool is tagged private;
>
>    package constructor is
>
>        procedure create (c : out cool; ... ... );
>
>    end constructor;
>
>    private
>        ...
>        ...
>
>end something_cool;
>
>or
>
>package something_cool is
>
>    type cool is tagged private;
>
>    procedure create (c : out cool; ... ... );
>
>    private
>        ...
>        ...
>
>end something_cool;
>
>
>What's the difference?  Where should i use method 1 and where should i
use
>method 2?


When you have the nested package, the constructor is not inherited when
the type is derived. (In RMese, it isn't a primitive operation of the
type.) Typically, each constructor has a separate set of parameters, and
you don't want the same parameters on the constructor for each type. Ada
95 doesn't let you delete operations that are inherited, so you have to
prevent them from being inherited in the first place.

The alternative (which we use in Claw) is to override *all* inherited
constructors, and either make them work or raise an exception. But that
only works well with a shallow inheritance structure; a deeper structure
could end up with dozens of useless constructors inherited.

            Randy.