Object-oriented Software in Ada 95

216 Polymorphism
15.3.1 Summary: access all, access constant, access
The following table summarizes the choice and restrictions that apply to the use of access values.
Note Declaration (T is an Integer type) Example of use
1 type P_T is access all T; a_pt := a_t'Access;
a_t : aliased T; a_pt.all := 2;
a_pt: P_T;
2 type P_T is access constant T;
a_t : aliased constant T := 0;
a_pt: P_T;
3 type P_T is access T;
a_pt: P_T;
a_pt := a_t'Access;
Put( a_pt.all );
a_pt := new T;
a_pt.all := 2;
Note 1: Used when it is required to have both read and write access to a_t using the access value held in
a_pt. The storage described by a_t may also be dynamically created using an allocator.
Note 2: Used when it is required to have only read access to a_t using the access value held in a_pt. The
storage described by a_t may also be dynamically created using an allocator.
Note 3: Used when the storage for an instance of a T is allocated dynamically. Access to an instance of T can
be read or written to using the access value obtained from new.
This form may only be used when an access value is created with an allocator (new T).
15.4 Use of dynamic storage
The Stack package shown in Section 14.3 could be rewritten using dynamic storage allocation. In rewriting this
package, the user interface to the package has not been changed. Thus, a user of this package would not need to
modify their program.
There is however, one important difference and this is that as the implementation of the stack uses linked
storage as the implementation stands it cannot be correctly copied. To prevent a user of the package from
attempting to copy an instance of a stack the type Stack is created as a limited type.
generic
type Stack_Element is private; --
package Class_Stack is
type Stack is limited private;
Stack_Error : exception;
--NO copying
procedure Push( The:in out Stack; Item:in Stack_Element );
procedure Pop(The:in out Stack; Item :out Stack_Element );
procedure Reset( The:in out Stack );
private
type Node;
type P_Node is access Node;
pragma Controlled( P_Node );
type Node is record
Item : Stack_Element;
P_Next : P_Node;
end record;
--Mutually recursive def
--Pointer to a Node
--We do deallocation
--Node holds the data
--The stored item
--Next in list
type Stack is record
P_Head : P_Node := null;
end record;
end Class_Stack;
--First node in list
Note:
The compiler directive pragma Controlled( P_Node ) to inform the compiler that the
programmer will explicitly perform the storage de-allocation for data allocated with the type P_Node.
© M A Smith - May not be reproduced without permission