Re: Idiom for a class and an object in Ada

[Matthew Heaney <matthewjheaney@earthlink.net>]

Simon Wright <simon@pushface.org> writes:

> I'm not so hung up as Matt about people using the word class (in
> conversation; I agree about use in Ada code). But I have to say,
> what's wrong with Matt's suggestion? seems to answer all your needs as
> stated so far ..

For reasons I can't fathom, many Ada95 developers still have a very
Ada83 mindset.

This is the canonical idiom in C++ for controlling instance creation:

class C {
public:

   static C* make( /* ... */ );
   static void free(C*);

   void f(); //whatever

private:

   C();
   C(const C&);

   ~C();

   C& operator=(const C&);
};

Here, the ctor (and dtor) is declared as private, so the only way to
make a C object is by calling factory function C::make().

This has a direct translation into Ada95:

package P is

   type T (<>) is limited private;

   procedure Op (O : in out T);

   type T_Access is access all T;

   function New_T (...) return T_Access;

private

   type T is limited record ...;

end P;


Here the package provides a factory function to dynamically create
instances (or possibly return a pointer to statically declared objects,
a la the Flyweight Pattern).

Functions in Ada95 return constant objects.  (In Ada83, functions
returned values.)  Types whose full view is limited are passed by
reference.  These two facts mean you can write the equivalent of a const
reference in C++:

   const C& f();

by using a function whose return type is limited:

package P is

   type T (<>) is limited private;

   procedure Op (O : in T);

   function Object1 return T;
   function Object2 return T;

private

   type T is limited record ...;

end P;


This is exactly how Text_IO works.  The objects returned by functions
Standard_Input, Standard_Output, etc, correspond to the functions
Object1 and Object2 above.

This is the canonical Ada95 idiom for controlling instance creation, and
for declaring well-known objects.