3.3.1 Object Declarations
declares a stand-alone
object with a given nominal subtype and,
optionally, an explicit initial value given by an initialization expression.
For an array,
task, or protected object, the object_declaration
may include the definition of the (anonymous) type of the object.
Name Resolution Rules
with the reserved word constant
declares a constant object.
it has an initialization expression, then it is called a full constant
Otherwise it is called a deferred
. The rules for deferred constant declarations
are given in clause 7.4
. The rules for full
constant declarations are given in this subclause.
Any declaration that includes a defining_identifier_list
with more than one defining_identifier
is equivalent to a series of declarations each containing one defining_identifier
from the list, with the rest of the text of the declaration copied for
each declaration in the series, in the same order as the list. The remainder
of this International Standard relies on this equivalence; explanations
are given for declarations with a single defining_identifier
A component of an object is
said to require late initialization
if it has an access discriminant
value constrained by a per-object expression, or if it has an initialization
expression that includes a name denoting the current instance of the
type or denoting an access discriminant.
If a composite object declared
by an object_declaration
has an unconstrained nominal subtype, then if this subtype is indefinite
or the object is constant the actual subtype of this object is constrained.
The constraint is determined by the bounds or discriminants (if any)
of its initial value;
the object is said to be constrained
by its initial value
not constrained by its initial value, the actual and nominal subtypes
of the object are the same.
its actual subtype is constrained, the object is called a constrained
without an initialization expression, any initial values for the object
or its subcomponents are determined by the implicit initial values
defined for its nominal subtype, as follows:
- The implicit initial value for an
access subtype is the null value of the access type.
- The implicit initial (and only) value
for each discriminant of a constrained discriminated subtype is defined
by the subtype.
- For a (definite) composite subtype,
the implicit initial value of each component with a default_expression
is obtained by evaluation of this expression and conversion to the component's
nominal subtype (which might raise Constraint_Error — see 4.6,
“Type Conversions”), unless the
component is a discriminant of a constrained subtype (the previous case),
or is in an excluded variant
(see 3.8.1). For each
component that does not have a default_expression,
any implicit initial values are those determined by the component's nominal
- For a protected or task subtype, there
is an implicit component (an entry queue) corresponding to each entry,
with its implicit initial value being an empty queue.
is first elaborated. This creates the nominal subtype (and the anonymous
type in the last four cases).
If the object_declaration
includes an initialization expression, the (explicit) initial value is
obtained by evaluating the expression and converting it to the nominal
subtype (which might raise Constraint_Error — see 4.6
The object is created, and, if there is not an initialization expression,
the object is initialized by default
an object is initialized by default, any per-object constraints (see
) are elaborated and any implicit initial
values for the object or for its subcomponents are obtained as determined
by the nominal subtype.
values (whether explicit or implicit) are assigned to the object or to
the corresponding subcomponents. As described in 5.2
, Initialize and Adjust procedures can
For the third step
above, evaluations and assignments are performed in an arbitrary order
subject to the following restrictions:
- Assignment to any part of the object
is preceded by the evaluation of the value that is to be assigned.
- The evaluation of a default_expression
that includes the name of a discriminant is preceded by the assignment
to that discriminant.
- The evaluation of the default_expression
for any component that depends on a discriminant is preceded by the assignment
to that discriminant.
- The assignments to any components,
including implicit components, not requiring late initialization must
precede the initial value evaluations for any components requiring late
initialization; if two components both require late initialization, then
assignments to parts of the component occurring earlier in the order
of the component declarations must precede the initial value evaluations
of the component occurring later.
There is no implicit initial value defined for a
In the absence of an explicit initialization,
a newly created scalar object might have a value that does not belong
to its subtype (see 13.9.1
7 Implicit initial values are not defined
for an indefinite subtype, because if an object's nominal subtype is
indefinite, an explicit initial value is required.
9 The type of a stand-alone object cannot
be abstract (see 3.9.3
Example of a multiple
-- the multiple object declaration
John, Paul : not null
Person_Name := new
Person(Sex => M); -- see 3.10.1
-- is equivalent to the two single object declarations in the order given
John : not null Person_Name := new Person(Sex => M);
Paul : not null Person_Name := new Person(Sex => M);
Examples of variable
Count, Sum : Integer;
Size : Integer range 0 .. 10_000 := 0;
Sorted : Boolean := False;
Color_Table : array(1 .. Max) of Color;
Option : Bit_Vector(1 .. 10) := (others => True);
Hello : aliased String := "Hi, world.";
θ, φ : Float range -π .. +π;
Examples of constant
Limit : constant
Integer := 10_000;
Low_Limit : constant
Integer := Limit/10;
Tolerance : constant
Real := Dispersion(1.15);
Hello_Msg : constant access
String := Hello'Access; -- see 3.10.2