3.3.1 Object Declarations
An
object_declaration
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.
Syntax
Name Resolution Rules
Legality Rules
Static Semantics
An
object_declaration
with the reserved word
constant declares a constant object.
If
it has an initialization expression, then it is called a
full constant
declaration.
Otherwise, it is called a
deferred
constant declaration. 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.
Dynamic Semantics
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.
When
not constrained by its initial value, the actual and nominal subtypes
of the object are the same.
If
its actual subtype is constrained, the object is called a
constrained
object.
For
an
object_declaration
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, “
Type
Conversions”);
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), 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,
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.
1.
The
subtype_indication,
access_definition,
array_type_definition,
single_task_declaration,
or
single_protected_declaration
is first elaborated. This creates the nominal subtype (and the anonymous
type in the last four cases).
2.
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).
3.
The object is created, and, if there is not an initialization expression,
the object is
initialized by default.
When
an object is initialized by default, any per-object constraints (see
3.8) are elaborated and any implicit initial
values for the object or for its subcomponents are obtained as determined
by the nominal subtype.
Any initial
values (whether explicit or implicit) are assigned to the object or to
the corresponding subcomponents. As described in
5.2
and
7.6, Initialize and Adjust procedures can
be called.
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
the type.
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
and
H.1).
10 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.
12 The type of a stand-alone object cannot
be abstract (see
3.9.3).
Examples
Example of a multiple
object declaration:
-- 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
declarations:
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
declarations:
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