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,
access, 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 subclause 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 value for a scalar subtype
that has the Default_Value aspect specified is the value of that aspect
converted to the nominal subtype (which might raise Constraint_Error
— see 4.6
The implicit initial (and only) value for each
discriminant of a constrained discriminated subtype is defined by the
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), unless the component
is a discriminant of a constrained subtype (the previous case), or is
in an excluded variant
component that does not have a default_expression
if the composite subtype has the Default_Component_Value aspect specified,
the implicit initial value is the value of that aspect converted to the
component's nominal subtype; otherwise, any implicit initial values are
those determined by the component's nominal subtype.
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
This paragraph was deleted.
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 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
precede the initial value evaluations of the component occurring later.
There is no implicit initial value defined for a
scalar subtype unless the Default_Value aspect has been specified for
In the absence of an explicit initialization
or the specification of the Default_Value aspect, a newly created scalar
object might have a value that does not belong to its subtype (see 13.9.1
13 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.
15 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
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe