# 3.6 Array Types

This Reference Manual output has not been verified, and may contain omissions or errors. Report any problems on the tracking issue

An *array* object is a composite object consisting of components which all have the same subtype. The name for a component of an array uses one or more index values belonging to specified discrete types. The value of an array object is a composite value consisting of the values of the components.

#### Syntax

2`array_type_definition`

` ::= `

`unconstrained_array_definition`

| `constrained_array_definition`

3`unconstrained_array_definition`

` ::= `

**array**(`index_subtype_definition`

{, `index_subtype_definition`

}) **of** `component_definition`

4`index_subtype_definition`

` ::= `

`subtype_mark`

**range** <>

5`constrained_array_definition`

` ::= `

**array** (`discrete_subtype_definition`

{, `discrete_subtype_definition`

}) **of** `component_definition`

6`discrete_subtype_definition`

` ::= `

*discrete_*`subtype_indication`

| `range`

7/2`component_definition`

` ::= `

[**aliased**] `subtype_indication`

| [**aliased**] `access_definition`

#### Name Resolution Rules

8For a `discrete_subtype_definition`

that is a `range`

, the `range`

shall resolve to be of some specific discrete type[; which discrete type shall be determined without using any context other than the bounds of the `range`

itself (plus the preference for *root_integer* — see 8.6).]

#### Legality Rules

9Each `index_subtype_definition`

or `discrete_subtype_definition`

in an `array_type_definition`

defines an *index subtype*; its type (the *index type*) shall be discrete.

*index*is a discrete quantity used to select along a given dimension of an array. A component is selected by specifying corresponding values for each of the indices.

The subtype defined by the `subtype_indication`

of a `component_definition`

(the *component subtype*) shall be a definite subtype.

`component_definition`

, including in `record_type_definition`

s and `protected_definition`

s.*This paragraph was deleted.*

#### Static Semantics

12An array is characterized by the number of indices (the *dimensionality* of the array), the type and position of each index, the lower and upper bounds for each index, and the subtype of the components. The order of the indices is significant.

A one-dimensional array has a distinct component for each possible index value. A multidimensional array has a distinct component for each possible sequence of index values that can be formed by selecting one value for each index position (in the given order). The possible values for a given index are all the values between the lower and upper bounds, inclusive; this range of values is called the *index range*. The *bounds* of an array are the bounds of its index ranges. The *length* of a dimension of an array is the number of values of the index range of the dimension (zero for a null range). The *length* of a one-dimensional array is the length of its only dimension.

An `array_type_definition`

defines an array type and its first subtype. For each object of this array type, the number of indices, the type and position of each index, and the subtype of the components are as in the type definition[; the values of the lower and upper bounds for each index belong to the corresponding index subtype of its type, except for null arrays (see 3.6.1)].

An `unconstrained_array_definition`

defines an array type with an unconstrained first subtype. Each `index_subtype_definition`

defines the corresponding index subtype to be the subtype denoted by the `subtype_mark`

. [ The compound delimiter <> (called a *box*) of an `index_subtype_definition`

stands for an undefined range (different objects of the type can have different bounds).]

A `constrained_array_definition`

defines an array type with a constrained first subtype. Each `discrete_subtype_definition`

defines the corresponding index subtype, as well as the corresponding index range for the constrained first subtype. The *constraint* of the first subtype consists of the bounds of the index ranges.

The discrete subtype defined by a `discrete_subtype_definition`

is either that defined by the `subtype_indication`

, or a subtype determined by the `range`

as follows:

- If the type of the
`range`

resolves to*root_integer*, then the`discrete_subtype_definition`

defines a subtype of the predefined type Integer with bounds given by a conversion to Integer of the bounds of the`range`

;

*universal_integer*s.

`range`

. However, this can introduce *Beaujolais*effects when the

`simple_expression`

s involve calls on functions visible due to **use**clauses.

- Otherwise, the
`discrete_subtype_definition`

defines a subtype of the type of the`range`

, with the bounds given by the`range`

.

The `component_definition`

of an `array_type_definition`

defines the nominal subtype of the components. If the reserved word **aliased** appears in the `component_definition`

, then each component of the array is aliased (see 3.10).

#### Dynamic Semantics

21The elaboration of an `array_type_definition`

creates the array type and its first subtype, and consists of the elaboration of any `discrete_subtype_definition`

s and the `component_definition`

.

{*8652/0002*} The elaboration of a `discrete_subtype_definition`

that does not contain any per-object expressions creates the discrete subtype, and consists of the elaboration of the `subtype_indication`

or the evaluation of the `range`

. The elaboration of a `discrete_subtype_definition`

that contains one or more per-object expressions is defined in 3.8. The elaboration of a `component_definition`

in an `array_type_definition`

consists of the elaboration of the `subtype_indication`

or `access_definition`

. The elaboration of any `discrete_subtype_definition`

s and the elaboration of the `component_definition`

are performed in an arbitrary order.

#### Static Semantics

22.1/3For an array type with a scalar component type, the following language-defined representation aspect may be specified with an `aspect_specification`

(see 13.1.1):

Default_Component_Value

- This aspect shall be specified by a static expression, and that expression shall be explicit, even if the aspect has a boolean type. Default_Component_Value shall be specified only on a
`full_type_declaration`

.

**out**parameters could be different whether or not a Default_Value is specified (see 6.4.1).

**Aspect Description for**

**Default_Component_Value:**Default value for the components of an array-of-scalar subtype.

If a derived type inherits a boolean Default_Component_Value aspect, the aspect may be specified to have any value for the derived type.

#### Name Resolution Rules

22.4/3The expected type for the `expression`

specified for the Default_Component_Value aspect is the component type of the array type defined by the `full_type_declaration`

on which it appears.

`array_type_definition`

creates a distinct array type. A consequence of this is that each object whose `object_declaration`

contains an `array_type_definition`

is of its own unique type. #### Examples

25*Examples of type declarations with unconstrained array definitions: *

```
type Vector is array(Integer range <>) of Real;
type Matrix is array(Integer range <>, Integer range <>) of Real;
type Bit_Vector is array(Integer range <>) of Boolean;
type Roman is array(Positive range <>) of Roman_Digit; -- see 3.5.2
```

27*Examples of type declarations with constrained array definitions: *

`type Table is array(1 .. 10) of Integer;`

type Schedule is array(Day) of Boolean;

type Line is array(1 .. Max_Line_Size) of Character;

*Examples of object declarations with array type definitions: *

```
Grid : array(1 .. 80, 1 .. 100) of Boolean;
Mix : array(Color range Red .. Green) of Boolean;
Msg_Table : constant array(Error_Code) of access constant String :=
(Too_Big => new String'("Result too big"), Too_Small => ...);
Page : array(Positive range <>) of Line := -- an array of arrays
(1 | 50 => Line'(1 | Line'Last => '+', others => '-'), -- see 4.3.3
2 .. 49 => Line'(1 | Line'Last => '|', others => ' '));
-- Page is constrained by its initial value to (1..50)
```

#### Extensions to Ada 83

`unconstrained_array_definition`

and `constrained_array_definition`

are modified to use `component_definition`

(instead of *component_*

`subtype_indication`

). The effect of this change is to allow the reserved word **aliased**before the component

`subtype_indication`

.`range`

in a `discrete_subtype_definition`

may use arbitrary universal expressions for each bound (e.g. –1 .. 3+5), rather than strictly "implicitly convertible" operands. The subtype defined will still be a subtype of Integer. #### Wording Changes from Ada 83

`discrete_subtype_definition`

, as distinct from `discrete_range`

. These two constructs have the same syntax, but their semantics are quite different (one defines a subtype, with a preference for Integer subtypes, while the other just selects a subrange of an existing subtype). We use this new syntactic category in **for**loops and entry families.

`index_constraint`

and `discrete_range`

have been moved to their own subclause, since they are no longer used here.`component_definition`

(formerly `component_subtype_definition`

) is moved here from RM83-3.7. #### Extensions to Ada 95

#### Wording Changes from Ada 95

*8652/0002*}

**Corrigendum:**Added wording to allow the elaboration of per-object constraints for constrained arrays.

#### Extensions to Ada 2005

## 3.6.1 Index Constraints and Discrete Ranges

1An `index_constraint`

determines the range of possible values for every index of an array subtype, and thereby the corresponding array bounds.

#### Syntax

2`index_constraint`

` ::= `

(`discrete_range`

{, `discrete_range`

})

3`discrete_range`

` ::= `

*discrete_*`subtype_indication`

| `range`

#### Name Resolution Rules

4The type of a `discrete_range`

is the type of the subtype defined by the `subtype_indication`

, or the type of the `range`

. For an `index_constraint`

, each `discrete_range`

shall resolve to be of the type of the corresponding index.

`index_constraint`

s only appear in a `subtype_indication`

; they no longer appear in `constrained_array_definition`

s. #### Legality Rules

5An `index_constraint`

shall appear only in a `subtype_indication`

whose `subtype_mark`

denotes either an unconstrained array subtype, or an unconstrained access subtype whose designated subtype is an unconstrained array subtype; in either case, the `index_constraint`

shall provide a `discrete_range`

for each index of the array type.

#### Static Semantics

6A `discrete_range`

defines a range whose bounds are given by the `range`

, or by the range of the subtype defined by the `subtype_indication`

.

#### Dynamic Semantics

7An `index_constraint`

is *compatible* with an unconstrained array subtype if and only if the index range defined by each `discrete_range`

is compatible (see 3.5) with the corresponding index subtype. If any of the `discrete_range`

s defines a null range, any array thus constrained is a *null array*, having no components. An array value *satisfies* an `index_constraint`

if at each index position the array value and the `index_constraint`

have the same index bounds.

The elaboration of an `index_constraint`

consists of the evaluation of the `discrete_range`

(s), in an arbitrary order. The evaluation of a `discrete_range`

consists of the elaboration of the `subtype_indication`

or the evaluation of the `range`

.

`subtype_indication`

consisting of a `subtype_mark`

followed by an `index_constraint`

checks the compatibility of the `index_constraint`

with the `subtype_mark`

(see 3.2.2).#### Examples

11*Examples of array declarations including an index constraint: *

```
Board : Matrix(1 .. 8, 1 .. 8); -- see 3.6
Rectangle : Matrix(1 .. 20, 1 .. 30);
Inverse : Matrix(1 .. N, 1 .. N); -- N can be nonstatic
13/5Filter : Bit_Vector(0 .. 31); -- see 3.6
```

14*Example of array declaration with a constrained array subtype: *

`My_Schedule : Schedule; -- all arrays of type Schedule have the same bounds`

*Example of record type with a component that is an array: *

```
type Var_Line(Length : Natural) is
record
Image : String(1 .. Length);
end record;
18Null_Line : Var_Line(0); -- Null_Line.Image is a null array
```

#### Extensions to Ada 83

#### Wording Changes from Ada 83

`index_constraint`

and `discrete_range`

here since they are no longer used in `constrained_array_definition`

s. We therefore also no longer have to describe the (special) semantics of `index_constraint`

s and `discrete_range`

s that appear in `constrained_array_definition`

s.## 3.6.2 Operations of Array Types

#### Legality Rules

1[The argument N used in the `attribute_designator`

s for the N-th dimension of an array shall be a static `expression`

of some integer type.] The value of N shall be positive (nonzero) and no greater than the dimensionality of the array.

#### Static Semantics

2/1{*8652/0006*} The following attributes are defined for a `prefix`

A that is of an array type [(after any implicit dereference)], or denotes a constrained array subtype:

A'First

- A'First denotes the lower bound of the first index range; its type is the corresponding index type.

A'First(N)- A'First(N) denotes the lower bound of the N-th index range; its type is the corresponding index type.

A'Last- A'Last denotes the upper bound of the first index range; its type is the corresponding index type.

A'Last(N)- A'Last(N) denotes the upper bound of the N-th index range; its type is the corresponding index type.

A'Range- A'Range is equivalent to the range A'First .. A'Last, except that the
`prefix`

A is only evaluated once. 8

A'Range(N)- A'Range(N) is equivalent to the range A'First(N) .. A'Last(N), except that the
`prefix`

A is only evaluated once. 9

A'Length- A'Length denotes the number of values of the first index range (zero for a null range); its type is
*universal_integer*. 10

A'Length(N)- A'Length(N) denotes the number of values of the N-th index range (zero for a null range); its type is
*universal_integer*.

#### Implementation Advice

11/3An implementation should normally represent multidimensional arrays in row-major order, consistent with the notation used for multidimensional array aggregates (see 4.3.3). However, if convention Fortran is specified for a multidimensional array type, then column-major order should be used instead (see B.5, “Interfacing with Fortran”).

`attribute_reference`

s A'First and A'First(1) denote the same value. A similar relation exists for the `attribute_reference`

s A'Last, A'Range, and A'Length. The following relation is satisfied (except for a null array) by the above attributes if the index type is an integer type: `A'Length(N) = A'Last(N) - A'First(N) + 1`

`indexed_component`

. A value of an array type can be specified with an `array_aggregate`

. For a one-dimensional array type, a slice of the array can be named; also, string literals are defined if the component type is a character type. #### Examples

17*Examples (using arrays declared in the examples of subclause 3.6.1):*

```
-- Filter'First = 0 Filter'Last = 31 Filter'Length = 32
-- Rectangle'Last(1) = 20 Rectangle'Last(2) = 30
```

## 3.6.3 String Types

#### Static Semantics

1A one-dimensional array type whose component type is a character type is called a *string type*.

[There are three predefined string types, String, Wide_String, and Wide_Wide_String, each indexed by values of the predefined subtype Positive; these are declared in the visible part of package Standard:]

```
[subtype Positive is Integer range 1 .. Integer'Last;
4/2type String is array(Positive range <>) of Character;
type Wide_String is array(Positive range <>) of Wide_Character;
type Wide_Wide_String is array(Positive range <>) of Wide_Wide_Character;
]
```

#### Examples

6*Examples of string objects:*

```
Stars : String(1 .. 120) := (1 .. 120 => '*' );
Question : constant String := "How many characters?";
-- Question'First = 1, Question'Last = 20
-- Question'Length = 20 (the number of characters)
8Ask_Twice : String := Question & Question; -- constrained to (1..40)
Ninety_Six : constant Roman := "XCVI"; -- see 3.5.2 and 3.6
```

#### Inconsistencies With Ada 83

`defining_identifier`

. In rare cases, this might result in an inconsistency between Ada 83 and Ada 95. #### Incompatibilities With Ada 83

`"a" < "bc"`

#### Extensions to Ada 83

#### Wording Changes from Ada 83

*string type*as a natural analogy to the term

*character type*.

#### Inconsistencies With Ada 95

`defining_identifier`

. In the (very) unlikely event that an Ada 95 program had depended on such a use-visible declaration, and the program remains legal after the substitution of Standard.Wide_Wide_String, the meaning of the program will be different.